= 5:\n raise UnhandledWorkflowException(\n f\"Training job '{self.experiment_record._next_model_to_train_id}' \"\n f\"was in state of '{self.experiment_record._training_state}'. Expected it to be TRAINED.\"\n )\n if (\n self.experiment_record._training_state == TrainingState.FAILED\n or self.experiment_record._training_state == TrainingState.STOPPED\n ):\n raise SageMakerTrainingJobException(\n f\"Training job '{self.experiment_record._next_model_to_train_id}' \"\n f\"ended in state of '{self.experiment_record._training_state}'. Please check Sagemaker logs for \"\n \"more information.\"\n )","def train(self):\r\n \r\n args = self.args\r\n model = self.model\r\n dataset = self.dataset\r\n train_state = self.train_state\r\n optimizer = self.optimizer\r\n scheduler = self.scheduler\r\n train_bar = self.train_bar\r\n val_bar = self.val_bar\r\n epoch_bar = self.epoch_bar\r\n \r\n for epoch_index in range(args.num_epochs):\r\n train_state['epoch_index'] = epoch_index\r\n \r\n # Iterate over training dataset\r\n \r\n running_loss,running_acc = self.train_loop(epoch_index, args, \r\n model, dataset, \r\n optimizer, train_bar)\r\n \r\n train_state['train_loss'].append(running_loss)\r\n train_state['train_acc'].append(running_acc)\r\n \r\n running_loss,running_acc = self.val_loop(epoch_index, args, model, \r\n dataset, optimizer, val_bar)\r\n \r\n \r\n train_state['val_loss'].append(running_loss)\r\n train_state['val_acc'].append(running_acc)\r\n \r\n print(\"Epoch \"+str(epoch_index+1)+\": Running loss=\"+ \\\r\n str(running_loss)+\", Running Acc=\"+str(running_acc))\r\n \r\n train_state = update_train_state(args=args, model=model, \r\n train_state=train_state)\r\n \r\n scheduler.step(train_state['val_loss'][-1])\r\n \r\n if train_state['stop_early']:\r\n break\r\n \r\n train_bar.n = 0\r\n val_bar.n = 0\r\n epoch_bar.set_postfix(best_val=train_state['early_stopping_best_val'] )\r\n epoch_bar.update()\r\n \r\n state_dict = torch.load(train_state['model_filename'])\r\n model.load_state_dict(state_dict)\r\n return model","def _train_model(self):\n raise NotImplementedError()","def train(self, train_loader):\n pass"],"string":"[\n \"def launch_training_job(parent_dir, data_dir, job_name, params):\\n # Create a new folder in parent_dir with unique_name \\\"job_name\\\"\\n model_dir = os.path.join(parent_dir, job_name)\\n if not os.path.exists(model_dir):\\n os.makedirs(model_dir)\\n\\n # Write parameters in json file\\n json_path = os.path.join(model_dir, 'params.json')\\n params.save(json_path)\\n\\n # Launch training with this config\\n cmd = \\\"{python} train.py --model_dir {model_dir} --data_dir {data_dir}\\\"\\n cmd = cmd.format(python=PYTHON, model_dir=model_dir, data_dir=data_dir)\\n print(cmd)\\n check_call(cmd, shell=True)\",\n \"def launch_job(self,\\n job_id: Text,\\n parent: Text,\\n training_input: Dict[Text, Any],\\n job_labels: Optional[Dict[Text, Text]] = None) -> None:\\n pass\",\n \"def launch_training_job(dataset_name, parent_dir, job_name, params):\\r\\n # Create a new folder in parent_dir with unique_name \\\"job_name\\\"\\r\\n model_dir = os.path.join(parent_dir, job_name)\\r\\n if not os.path.exists(model_dir):\\r\\n os.makedirs(model_dir)\\r\\n\\r\\n # Write parameters in json file\\r\\n json_path = os.path.join(model_dir, 'params.json')\\r\\n params.model_dir = model_dir\\r\\n params.save(json_path)\\r\\n\\r\\n # Launch training with this config\\r\\n exrta_paras_dict = {'train_window_size':params.train_window_size,\\r\\n 'test_window_size': params.test_window_size}\\r\\n if dataset_name == \\\"ucsd_ped1\\\":\\r\\n dataset_train = UCSDPed1_deepSVDD_TRAIN(path=params.train_dir,\\r\\n exrta_paras_dict=exrta_paras_dict)\\r\\n dataset_eval = UCSDPed1_deepSVDD(path=params.test_dir,\\r\\n exrta_paras_dict=exrta_paras_dict)\\r\\n if dataset_name == \\\"ucsd_ped2\\\":\\r\\n dataset_train = UCSDPed2_deepSVDD_TRAIN(path=params.train_dir,\\r\\n exrta_paras_dict=exrta_paras_dict)\\r\\n dataset_eval = UCSDPed2_deepSVDD(path=params.test_dir,\\r\\n exrta_paras_dict=exrta_paras_dict)\\r\\n # mutli_task train，这次使用逻辑上的分阶段训练：代码实现上用权重来控制\\r\\n # 先给rec loss极高的权重，只训练rec loss；然后只训练 probability loss\\r\\n # 最后恢复权重，联合训练 rec loss + deep_SVDD loss\\r\\n model = LSAUCSD_deepSVDD(input_shape=dataset_train.shape,\\r\\n code_length=params.code_length)\\r\\n # Set up result helper and perform test\\r\\n helper = VideoAnomalyDetectionResultHelper_deepSVDD(\\r\\n dataset_train, dataset_eval, model, params)\\r\\n helper.hyperparas_search()\",\n \"def _setup_training(self, params, **kwargs):\\n model_params = params.permute_training_on_top().model\\n\\n model_kwargs = {**model_params.fixed, **model_params.variable}\\n\\n model = self.model_cls(**model_kwargs)\\n\\n training_params = params.permute_training_on_top().training\\n losses = training_params.nested_get(\\\"losses\\\")\\n optimizer_cls = training_params.nested_get(\\\"optimizer_cls\\\")\\n optimizer_params = training_params.nested_get(\\\"optimizer_params\\\")\\n train_metrics = training_params.nested_get(\\\"train_metrics\\\", {})\\n lr_scheduler_cls = training_params.nested_get(\\\"lr_sched_cls\\\", None)\\n lr_scheduler_params = training_params.nested_get(\\\"lr_sched_params\\\",\\n {})\\n val_metrics = training_params.nested_get(\\\"val_metrics\\\", {})\\n\\n # necessary for resuming training from a given path\\n save_path = kwargs.pop(\\\"save_path\\\", os.path.join(\\n self.save_path,\\n \\\"checkpoints\\\",\\n \\\"run_%02d\\\" % self._run))\\n\\n return self.trainer_cls(\\n network=model,\\n save_path=save_path,\\n losses=losses,\\n key_mapping=self.key_mapping,\\n optimizer_cls=optimizer_cls,\\n optimizer_params=optimizer_params,\\n train_metrics=train_metrics,\\n val_metrics=val_metrics,\\n lr_scheduler_cls=lr_scheduler_cls,\\n lr_scheduler_params=lr_scheduler_params,\\n optim_fn=self._optim_builder,\\n save_freq=self.checkpoint_freq,\\n **kwargs\\n )\",\n \"def train(self, current_hyper_params):\\n train_loss = 0\\n train_n_iter = 0\\n # Set model to train mode\\n self.model.train()\\n # Iterate over train data\\n print(\\\"Iterating over training data...\\\")\\n for i, batch in enumerate(tqdm(self.train_loader)):\\n loss = self._train_batch(batch)\\n # Statistics\\n train_loss += loss.item()\\n train_n_iter += 1\\n self.stats.train_loss_history.append(train_loss / train_n_iter)\",\n \"def train(self, single=False):\\n self.baseline=None\\n\\n dag = utils.load_dag(self.args,self.logger) if single else None\\n \\n if self.args.shared_initial_step > 0:\\n self.train_shared(self.args.shared_initial_step)\\n self.train_controller()\\n\\n for self.epoch in range(self.start_epoch, self.args.max_epoch):\\n # 1. Training the shared parameters omega of the child models\\n self.train_shared(dag=dag)\\n\\n # 2. Training the controller parameters theta\\n if not single:\\n self.train_controller()\\n\\n if self.epoch % self.args.save_epoch == 0 and self.epoch!=0:\\n with _get_no_grad_ctx_mgr():\\n best_dag = dag if dag else self.derive()\\n self.evaluate(best_dag,batch_size=self.args.batch_size)\\n self.save_model()\\n\\n if self.epoch >= self.args.shared_decay_after:\\n utils.update_lr(self.shared_optim, self.shared_lr)\\n self.save_model()\\n self.dag_file.close()\",\n \"def run_training(self, schema_params, export_model=False, output_model_dir=None):\\n # Log distributed execution context, which includes cluster configuration\\n logger.info(f\\\"Commencing {self.effect_name} training\\\")\\n logger.info(f\\\"Execution context : {self.execution_context}\\\")\\n\\n # Create partition_index_list\\n partition_index_list = self._get_partition_list()\\n logger.info(f\\\"This worker on work on the following list of partitions : {partition_index_list}\\\")\\n\\n # Sequentially train model on partitions\\n for partition_index in partition_index_list:\\n logger.info(f\\\"Commencing {self.effect_name} training for partition index : {partition_index}\\\")\\n\\n # Resolve partitioned data directory from raw path params from user\\n checkpoint_path = self._anchor_directory(\\n self.model.checkpoint_path,\\n partition_index)\\n training_data_dir = self._anchor_directory(self.model.training_data_dir,\\n partition_index)\\n validation_data_dir = self._anchor_directory(self.model.validation_data_dir,\\n partition_index) if self.model.validation_data_dir else None\\n\\n if is_empty_directory(training_data_dir):\\n logger.info(f\\\"{training_data_dir} is empty, no dataset to train on.\\\")\\n continue\\n # Train model\\n self.execution_context[constants.PARTITION_INDEX] = partition_index\\n self.model.train(training_data_dir=training_data_dir,\\n validation_data_dir=validation_data_dir,\\n metadata_file=self.model.metadata_file,\\n checkpoint_path=checkpoint_path,\\n execution_context=self._prepare_training_context(partition_index),\\n schema_params=schema_params)\\n\\n # Chief should export model\\n is_chief = self.execution_context[constants.IS_CHIEF]\\n if export_model and is_chief:\\n logger.info(f\\\"Exporting model to directory : {output_model_dir}\\\")\\n self.model.export(output_model_dir=output_model_dir)\",\n \"def train(args):\\n print(args)\\n\\n # Run a training job\\n configs = LuxMatchConfigs_Default\\n\\n # Create a default opponent agent\\n opponent = Agent()\\n\\n # Create a RL agent in training mode\\n player = AgentPolicy(mode=\\\"train\\\")\\n\\n # Train the model\\n num_cpu = 1\\n if num_cpu == 1:\\n env = LuxEnvironment(configs=configs,\\n learning_agent=player,\\n opponent_agent=opponent)\\n else:\\n env = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(num_cpu)])\\n run_id = args.id\\n print(\\\"Run id %s\\\" % run_id)\\n\\n if args.path:\\n # by default previous model params are used (lr, batch size, gamma...)\\n model = PPO.load(args.path)\\n model.set_env(env=env)\\n\\n # Update the learning rate\\n model.lr_schedule = get_schedule_fn(args.learning_rate)\\n\\n # TODO: Update other training parameters\\n else:\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate=args.learning_rate,\\n gamma=args.gamma,\\n gae_lambda=args.gae_lambda,\\n batch_size=args.batch_size,\\n n_steps=args.n_steps\\n )\\n\\n print(\\\"Training model...\\\")\\n # Save a checkpoint every 1M steps\\n checkpoint_callback = CheckpointCallback(save_freq=1000000,\\n save_path='./models/',\\n name_prefix=f'rl_model_{run_id}')\\n model.learn(total_timesteps=args.step_count,\\n callback=checkpoint_callback) # 20M steps\\n if not os.path.exists(f'models/rl_model_{run_id}_{args.step_count}_steps.zip'):\\n model.save(path=f'models/rl_model_{run_id}_{args.step_count}_steps.zip')\\n print(\\\"Done training model.\\\")\\n\\n # Inference the model\\n print(\\\"Inference model policy with rendering...\\\")\\n saves = glob.glob(f'models/rl_model_{run_id}_*_steps.zip')\\n latest_save = sorted(saves, key=lambda x: int(x.split('_')[-2]), reverse=True)[0]\\n model.load(path=latest_save)\\n obs = env.reset()\\n for i in range(600):\\n action_code, _states = model.predict(obs, deterministic=True)\\n obs, rewards, done, info = env.step(action_code)\\n if i % 5 == 0:\\n print(\\\"Turn %i\\\" % i)\\n env.render()\\n\\n if done:\\n print(\\\"Episode done, resetting.\\\")\\n obs = env.reset()\\n print(\\\"Done\\\")\\n\\n '''\\n # Learn with self-play against the learned model as an opponent now\\n print(\\\"Training model with self-play against last version of model...\\\")\\n player = AgentPolicy(mode=\\\"train\\\")\\n opponent = AgentPolicy(mode=\\\"inference\\\", model=model)\\n env = LuxEnvironment(configs, player, opponent)\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate = 0.0003,\\n gamma=0.999,\\n gae_lambda = 0.95\\n )\\n\\n model.learn(total_timesteps=2000)\\n env.close()\\n print(\\\"Done\\\")\\n '''\",\n \"def train_model(self, *args, **kwargs):\\n self.model.train(self.training, *args, **kwargs)\",\n \"def train(self, absList, modelFilename):\\n pass\",\n \"def train_model(self):\\n if not self.is_exist(self.path_model_directory):\\n # Then create the parent folder\\n os.makedirs(self.path_model_directory)\\n\\n # Create a meta-data pickle for the model\\n self.create_meta_data_pickle()\\n\\n # Necessary meta-data file must be created before starting the training. Check if the file exists\\n if self.is_exist(self.path_model_metadata):\\n\\n # We do not need to train a model if there is already a best model for the same training exist\\n try:\\n self.model = load_model(self.path_best_model)\\n return\\n except:\\n self.log_event('There is no best trained model found in the parent folder. Going with the training...')\\n\\n # Load the model meta-data\\n self.load_model_metadata()\\n self.encoding_vector_size = self.number_of_distinct_items\\n\\n # Iterate trough the split data for the training\\n for split_number in range(self.k_split):\\n split_path = f'split_{str(split_number)}/'\\n split_directory = self.path_model_directory + split_path\\n\\n # Check the split directory is already created. If it is, then we can directly start the training by using the existing data\\n if self.is_exist(split_directory):\\n try:\\n self.load_best_tuned_model(split_number)\\n except (IndexError, FileNotFoundError):\\n self.load_fold_k_data_and_fit(split_number=int(split_number))\\n\\n else:\\n # Create a folder for the split data and prepare the data for the training\\n os.makedirs(split_directory)\\n\\n # Create an array which will contain train features-labels and test features-labels\\n train_array = np.full(4, fill_value=self.mask_value, dtype=object)\\n train_index = 0\\n for position, split_name in enumerate(['train_split_', 'test_split_']):\\n training_features_directory = split_directory + f'{split_name}{str(split_number)}_all_training_features.data'\\n training_targets_directory = split_directory + f'{split_name}{str(split_number)}_all_training_targets.data'\\n fold_directory = self.path_shared_folds + f'{split_name}{str(split_number)}.fold'\\n\\n self.process_training_data(fold_directory=fold_directory)\\n\\n self.save_data_to_disk(data_to_save=self.all_features, path_to_save=training_features_directory)\\n train_array[train_index] = self.all_features\\n train_index += 1\\n self.all_features = None # Memory Management\\n\\n self.save_data_to_disk(data_to_save=self.all_targets, path_to_save=training_targets_directory)\\n train_array[train_index] = self.all_targets\\n train_index += 1\\n self.all_targets = None # Memory Management\\n\\n # Assign the input data to respective variables for the training\\n self.train_features = train_array[0]\\n self.train_targets = train_array[1]\\n self.test_features = train_array[2]\\n self.test_targets = train_array[3]\\n del train_array\\n\\n self.start_hyper_parameter_tuning(split_number)\\n\\n self.retrieve_best_model(metric=self.hyper_parameters['metric'])\",\n \"def start_training(self, logdir: str, **info):\\n pass\",\n \"def train_model(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def train(args):\\n print(args)\\n\\n # Run a training job\\n configs = LuxMatchConfigs_Default\\n\\n # Create a default opponent agent\\n opponent = Agent()\\n\\n # Create a RL agent in training mode\\n player = AgentPolicy(mode=\\\"train\\\")\\n\\n # Train the model\\n env_eval = None\\n if args.n_envs == 1:\\n env = LuxEnvironment(configs=configs,\\n learning_agent=player,\\n opponent_agent=opponent)\\n else:\\n env = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(args.n_envs)])\\n \\n run_id = args.id\\n print(\\\"Run id %s\\\" % run_id)\\n\\n if args.path:\\n # by default previous model params are used (lr, batch size, gamma...)\\n model = PPO.load(args.path)\\n model.set_env(env=env)\\n\\n # Update the learning rate\\n model.lr_schedule = get_schedule_fn(args.learning_rate)\\n\\n # TODO: Update other training parameters\\n else:\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate=args.learning_rate,\\n gamma=args.gamma,\\n gae_lambda=args.gae_lambda,\\n batch_size=args.batch_size,\\n n_steps=args.n_steps\\n )\\n\\n \\n \\n callbacks = []\\n\\n # Save a checkpoint and 5 match replay files every 100K steps\\n player_replay = AgentPolicy(mode=\\\"inference\\\", model=model)\\n callbacks.append(\\n SaveReplayAndModelCallback(\\n save_freq=100000,\\n save_path='./models/',\\n name_prefix=f'model{run_id}',\\n replay_env=LuxEnvironment(\\n configs=configs,\\n learning_agent=player_replay,\\n opponent_agent=Agent()\\n ),\\n replay_num_episodes=5\\n )\\n )\\n \\n # Since reward metrics don't work for multi-environment setups, we add an evaluation logger\\n # for metrics.\\n if args.n_envs > 1:\\n # An evaluation environment is needed to measure multi-env setups. Use a fixed 4 envs.\\n env_eval = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(4)])\\n\\n callbacks.append(\\n EvalCallback(env_eval, best_model_save_path=f'./logs_{run_id}/',\\n log_path=f'./logs_{run_id}/',\\n eval_freq=args.n_steps*2, # Run it every 2 training iterations\\n n_eval_episodes=30, # Run 30 games\\n deterministic=False, render=False)\\n )\\n\\n print(\\\"Training model...\\\")\\n model.learn(total_timesteps=args.step_count,\\n callback=callbacks)\\n if not os.path.exists(f'models/rl_model_{run_id}_{args.step_count}_steps.zip'):\\n model.save(path=f'models/rl_model_{run_id}_{args.step_count}_steps.zip')\\n print(\\\"Done training model.\\\")\\n\\n # Inference the model\\n print(\\\"Inference model policy with rendering...\\\")\\n saves = glob.glob(f'models/rl_model_{run_id}_*_steps.zip')\\n latest_save = sorted(saves, key=lambda x: int(x.split('_')[-2]), reverse=True)[0]\\n model.load(path=latest_save)\\n obs = env.reset()\\n for i in range(600):\\n action_code, _states = model.predict(obs, deterministic=True)\\n obs, rewards, done, info = env.step(action_code)\\n if i % 5 == 0:\\n print(\\\"Turn %i\\\" % i)\\n env.render()\\n\\n if done:\\n print(\\\"Episode done, resetting.\\\")\\n obs = env.reset()\\n print(\\\"Done\\\")\\n\\n '''\\n # Learn with self-play against the learned model as an opponent now\\n print(\\\"Training model with self-play against last version of model...\\\")\\n player = AgentPolicy(mode=\\\"train\\\")\\n opponent = AgentPolicy(mode=\\\"inference\\\", model=model)\\n env = LuxEnvironment(configs, player, opponent)\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate = 0.0003,\\n gamma=0.999,\\n gae_lambda = 0.95\\n )\\n model.learn(total_timesteps=2000)\\n env.close()\\n print(\\\"Done\\\")\\n '''\",\n \"def pretrained():\\n launch_training_on_all_splits(experiment='full', splits=NAME_SPLIT, base_model='pretrained', dropout=0.7987, learning_rate=0.00009659)\",\n \"def train(self, absList, modelFilename):\\n raise NotImplementedError(\\\"Need to implement train()\\\")\",\n \"def launch_training_job(master_nodes, trainset_date, opts, ec2_opts):\\n # TODO: check whether HDFS is running\\n # TODO: check whether YARN is running\\n master = master_nodes[0].public_dns_name\\n print(\\\"Setting up HDFS on the cluster..\\\")\\n ssh(host=master, opts=ec2_opts, command=\\\"chmod u+x /root/spark-ec2/setup_pricer_data.sh\\\")\\n ssh(host=master, opts=ec2_opts, command=\\\"/root/spark-ec2/setup_pricer_data.sh\\\")\\n print(\\\"Running trainer with train date={d}..\\\".format(d=trainset_date))\\n ssh(host=master, opts=ec2_opts, command=\\\"chmod u+x /root/spark-ec2/run_aws_trainer.sh\\\")\\n ssh(host=master, opts=ec2_opts, command=\\\"nohup /root/spark-ec2/run_aws_trainer.sh {d} 2>&1 </dev/null |tee log.aws_trainer\\\".format(d=trainset_date))\\n print(\\\"Trainer was launched successfully..\\\")\",\n \"def train_and_eval(params: flags.FlagValues) -> tf.keras.callbacks.History:\\n logging.info('Run training for {} with {}'.format(params.model_name,\\n params.dataset_name))\\n logging.info('The CLI params are: {}'.format(params.flag_values_dict()))\\n d_config = _get_dataset_config().get(params.dataset_name)()\\n m_config = _get_model_config().get(params.model_name)()\\n\\n logging.info('Training dataset configuration:', d_config)\\n logging.info('Training model configuration:', m_config)\\n\\n # override the model params with CLI params\\n m_config.num_classes = d_config.num_classes\\n m_config.dropout_keep_prob = 1 - params.dropout_rate\\n m_config.weight_decay = params.std_weight_decay\\n m_config.stddev = params.truncated_normal_stddev\\n m_config.batch_norm_decay = params.batch_norm_decay\\n\\n strategy = tf.distribute.MirroredStrategy()\\n with strategy.scope():\\n # override the dataset params with CLI params\\n if params.data_dir:\\n d_config.data_dir = params.data_dir\\n global_batch_size = params.batch_size * strategy.num_replicas_in_sync\\n\\n # override the dataset params with CLI params\\n # for distributed training, update batch size\\n d_config.batch_size = global_batch_size\\n # determine whether one_hot is used based on label_smoothing\\n d_config.one_hot = params.label_smoothing and params.label_smoothing > 0\\n\\n # build train dataset\\n train_dataset = get_dataset(d_config)\\n # build validation dataset\\n d_config.split = 'validation'\\n eval_dataset = get_dataset(d_config)\\n\\n # compute number iterations per epoch\\n steps_per_epoch = d_config.num_examples // d_config.batch_size\\n eval_steps = d_config.num_eval_examples // d_config.batch_size\\n\\n # build the model\\n keras_model = build_model(\\n model_name=params.model_name,\\n dataset_config=d_config,\\n model_config=m_config\\n )\\n\\n # build the optimizer\\n learning_params = defaults.LR_CONFIG_DEFAULT\\n learning_params.update({'initial_lr': params.lr,\\n 'decay_epochs': params.lr_decay_epochs,\\n 'decay_rate': params.lr_decay_rate})\\n optimizer_params = defaults.OP_CONFIG_DEFAULT\\n optimizer_params.update({'decay': params.op_decay_rate,\\n 'momentum': params.op_momentum})\\n optimizer = _get_optimizer(\\n batch_size=global_batch_size,\\n steps_per_epoch=steps_per_epoch,\\n lr_name=params.learning_scheduler_name,\\n optimizer_name=params.optimizer_name,\\n lr_params=learning_params,\\n optimizer_params=optimizer_params\\n )\\n\\n logging.info('Exponential decay rate:{}'.format(params.ma_decay_rate))\\n if params.ma_decay_rate:\\n optimizer = tfa.optimizers.MovingAverage(\\n optimizer=optimizer,\\n average_decay=params.ma_decay_rate)\\n\\n # compile model\\n if d_config.one_hot:\\n loss_obj = tf.keras.losses.CategoricalCrossentropy(\\n label_smoothing=params.label_smoothing)\\n else:\\n loss_obj = tf.keras.losses.SparseCategoricalCrossentropy()\\n\\n keras_model.compile(\\n optimizer=optimizer,\\n loss=loss_obj,\\n metrics=[_get_metrics(one_hot=d_config.one_hot)['acc']],\\n )\\n\\n logging.info(keras_model.summary())\\n\\n initial_epoch = 0\\n if params.resume_checkpoint:\\n initial_epoch = _resume_from_checkpoint(model=keras_model,\\n model_dir=params.model_dir,\\n train_steps=steps_per_epoch)\\n\\n # Callbacks\\n callbacks_to_use = _get_callback(model_dir=params.model_dir)\\n\\n # Train model\\n history = keras_model.fit(\\n train_dataset,\\n steps_per_epoch=steps_per_epoch,\\n epochs=params.epochs,\\n validation_data=eval_dataset,\\n validation_steps=eval_steps,\\n initial_epoch=initial_epoch,\\n verbose=1,\\n callbacks=callbacks_to_use\\n )\\n\\n return history\",\n \"def call_training_routine(self):\\n training_command = \\\"th main.lua \\\"\\\\\\n \\\"-GPU_id %(GPU_identifier)i \\\"\\\\\\n \\\"-number_of_GPUs %(number_of_GPUs)i \\\"\\\\\\n \\\"-training_dataset %(training_dataset)s \\\"\\\\\\n \\\"-testing_dataset %(testing_dataset)s \\\"\\\\\\n \\\"-modelFilePath %(modelFilePath)s \\\"\\\\\\n \\\"-maxepoch %(maxepoch)i \\\"\\\\\\n \\\"-savingDirectory %(savingDirectory)s \\\"\\\\\\n \\\"-learningRate %(learningRate)f \\\"\\\\\\n \\\"-batchSize %(batchSize)i \\\"\\\\\\n \\\"-momentum %(momentum)f\\\" % self.training_parameters\\n\\n if self.training_parameters[\\\"presavedModelPath\\\"] != \\\"\\\":\\n training_command += \\\" -presavedModelPath %s\\\" %\\\\\\n self.training_parameters[\\\"presavedModelPath\\\"]\\n\\n # Call the training command\\n subprocess.call(training_command, shell=True)\",\n \"def train(self):\\n # Change directory to the code directory\\n current_working_directory = os.getcwd()\\n\\n os.chdir(self.model_parameters[\\\"NN_code_directory\\\"])\\n\\n self.call_training_routine()\\n\\n # Come back to the original directory\\n os.chdir(current_working_directory)\",\n \"def train( # type: ignore\\n self,\\n pl_trainer_args: Dict[str, Any],\\n model_args: Dict[str, Union[float, str, int]],\\n dataset_args: Dict[str, Union[float, str, int]],\\n dataset: GFlowNetDataset,\\n environment: GraphBuildingEnv,\\n context: GraphBuildingEnvContext,\\n task: GFlowNetTask,\\n ) -> None:\\n\\n logger.info(f\\\"Trainer arguments: {pl_trainer_args}\\\")\\n\\n if pl_trainer_args[\\n \\\"resume_from_checkpoint\\\"\\n ] is not None and not pl_trainer_args[\\\"resume_from_checkpoint\\\"].endswith(\\n \\\".ckpt\\\"\\n ):\\n pl_trainer_args[\\\"resume_from_checkpoint\\\"] = None\\n\\n pl_trainer_args[\\\"callbacks\\\"] = {\\n \\\"model_checkpoint_callback\\\": {\\\"save_top_k\\\": pl_trainer_args[\\\"save_top_k\\\"]}\\n }\\n\\n pl_trainer_args[\\\"callbacks\\\"] = self.add_callbacks(pl_trainer_args[\\\"callbacks\\\"])\\n\\n pl_trainer_args[\\\"logger\\\"] = TensorBoardLogger(\\n pl_trainer_args[\\\"save_dir\\\"], name=pl_trainer_args[\\\"basename\\\"]\\n )\\n\\n trainer = Trainer(\\n profiler=pl_trainer_args[\\\"profiler\\\"],\\n logger=pl_trainer_args[\\\"logger\\\"],\\n log_every_n_steps=pl_trainer_args[\\\"trainer_log_every_n_steps\\\"],\\n callbacks=pl_trainer_args[\\\"callbacks\\\"],\\n max_epochs=pl_trainer_args[\\\"epochs\\\"],\\n strategy=pl_trainer_args[\\\"strategy\\\"],\\n fast_dev_run=pl_trainer_args[\\\"development_mode\\\"],\\n )\\n\\n data_module, model_module = self.get_data_and_model_modules(\\n model_args,\\n dataset_args,\\n pl_trainer_args,\\n dataset,\\n environment,\\n context,\\n task,\\n )\\n trainer.fit(model_module, data_module)\",\n \"def main(args, base_dir):\\n for i in range(args.n_training):\\n # value of the next seed\\n seed = args.seed + i\\n\\n # The time when the current experiment started.\\n now = strftime(\\\"%Y-%m-%d-%H:%M:%S\\\")\\n\\n # Create a save directory folder (if it doesn't exist).\\n if args.log_dir is not None:\\n dir_name = args.log_dir\\n else:\\n dir_name = os.path.join(base_dir, '{}/{}'.format(\\n args.env_name, now))\\n ensure_dir(dir_name)\\n\\n # Get the policy class.\\n if args.alg == \\\"TD3\\\":\\n from hbaselines.multiagent.td3 import MultiFeedForwardPolicy\\n elif args.alg == \\\"SAC\\\":\\n from hbaselines.multiagent.sac import MultiFeedForwardPolicy\\n elif args.alg == \\\"PPO\\\":\\n from hbaselines.multiagent.ppo import MultiFeedForwardPolicy\\n elif args.alg == \\\"TRPO\\\":\\n from hbaselines.multiagent.trpo import MultiFeedForwardPolicy\\n else:\\n raise ValueError(\\\"Unknown algorithm: {}\\\".format(args.alg))\\n\\n # Get the hyperparameters.\\n hp = get_hyperparameters(args, MultiFeedForwardPolicy)\\n\\n # add the seed for logging purposes\\n params_with_extra = hp.copy()\\n params_with_extra['seed'] = seed\\n params_with_extra['env_name'] = args.env_name\\n params_with_extra['policy_name'] = \\\"MultiFeedForwardPolicy\\\"\\n params_with_extra['algorithm'] = args.alg\\n params_with_extra['date/time'] = now\\n\\n # Add the hyperparameters to the folder.\\n with open(os.path.join(dir_name, 'hyperparameters.json'), 'w') as f:\\n json.dump(params_with_extra, f, sort_keys=True, indent=4)\\n\\n run_exp(\\n env=args.env_name,\\n policy=MultiFeedForwardPolicy,\\n hp=hp,\\n dir_name=dir_name,\\n evaluate=args.evaluate,\\n seed=seed,\\n eval_interval=args.eval_interval,\\n log_interval=args.log_interval,\\n save_interval=args.save_interval,\\n initial_exploration_steps=args.initial_exploration_steps,\\n ckpt_path=args.ckpt_path,\\n )\",\n \"def setup_training(args: argparse.Namespace) -> None:\\n # 1. Read hyperparameters from file\\n hp = HParams.from_yaml(args.path_config)\\n # check if GPU available and add it to parameters\\n hp[\\\"device\\\"] = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\\n\\n # 2. Create extension of the architecture of the model and timestamp for this run (use to\\n # identify folders and files created for this run)\\n # format: f(params_file)_t(n_tiers)_l(n_layers)_hd(hidden_size)_gmm(gmm_size).\\n extension_architecture = f\\\"d{hp.name}_t{hp.network.n_tiers}_\\\" \\\\\\n f\\\"l{'.'.join(map(str, hp.network.layers))}_\\\" \\\\\\n f\\\"hd{hp.network.hidden_size}_gmm{hp.network.gmm_size}\\\"\\n timestamp = f\\\"{datetime.now().strftime('%Y%m%d-%H%M%S')}\\\"\\n\\n # 3 Create directories for saving logs and model weights if they do not exist\\n # 3.1 Create model weights directory for this run (the same directory will be used for different\\n # runs of a model with same architecture and the difference will be in the file stored)\\n hp[\\\"training\\\"][\\\"dir_chkpt\\\"] = hp.training.dir_chkpt + extension_architecture\\n Path(hp.training.dir_chkpt).mkdir(parents=True, exist_ok=True)\\n # 3.2 Create general log directory for this run (the same directory will be used for different\\n # runs of a model with same architecture and the difference will be in the file stored)\\n hp[\\\"logging\\\"][\\\"dir_log\\\"] = hp.logging.dir_log + extension_architecture\\n Path(hp.logging.dir_log).mkdir(parents=True, exist_ok=True)\\n\\n # 4. Setup general logging (it will use the folder previously created and the filename will be:\\n tier = str(args.tier) if args.tier is not None else 'ALL'\\n filename = f\\\"{hp.logging.dir_log}/tier{tier}_{timestamp}\\\"\\n logging.basicConfig(\\n level=logging.INFO,\\n format='%(asctime)s - %(levelname)s - %(message)s',\\n handlers=[\\n logging.FileHandler(filename=filename), # handler to save the log to a file\\n logging.StreamHandler() # handler to output the log to the terminal\\n ])\\n logger = logging.getLogger()\\n\\n # 5. Show device that will be used for training: CPU or GPU\\n logger.info(f\\\"Device for training: {hp.device}\\\")\\n\\n # 6. Start training of the model (or a single tier, depending on args)\\n train_model(args, hp, extension_architecture, timestamp, logger)\",\n \"def train(project_id, python_module=None, package_uris=None, \\n region=None, args=None, job_dir=None, python_version=None, \\n runtime_version=None, master_image_uri=None, worker_image_uri=None, \\n training_input=None, job_id_prefix=None, wait_interval=30):\\n if not training_input:\\n training_input = {}\\n if python_module:\\n training_input['pythonModule'] = python_module\\n if package_uris:\\n training_input['packageUris'] = package_uris\\n if region:\\n training_input['region'] = region\\n if args:\\n training_input['args'] = args\\n if job_dir:\\n training_input['jobDir'] = job_dir\\n if python_version:\\n training_input['pythonVersion'] = python_version\\n if runtime_version:\\n training_input['runtimeVersion'] = runtime_version\\n if master_image_uri:\\n if 'masterConfig' not in training_input:\\n training_input['masterConfig'] = {}\\n training_input['masterConfig']['imageUri'] = master_image_uri\\n if worker_image_uri:\\n if 'workerConfig' not in training_input:\\n training_input['workerConfig'] = {}\\n training_input['workerConfig']['imageUri'] = worker_image_uri\\n job = {\\n 'trainingInput': training_input\\n }\\n return create_job(project_id, job, job_id_prefix, wait_interval)\",\n \"def train(self):\\n backend = self.config.backend.build(self.config, self.tmp_dir)\\n backend.train(source_bundle_uri=self.config.source_bundle_uri)\",\n \"def train_loop(job_name,\\n agent,\\n save_dir,\\n seed = 0,\\n niter = 101,\\n gamma = 0.995,\\n gae_lambda = None,\\n num_cpu = 1,\\n sample_mode = 'trajectories',\\n num_samples = None,\\n save_freq = 10,\\n evaluation_rollouts = None,\\n plot_keys = ['stoc_pol_mean']):\\n # Validate parameters.\\n if not os.path.isdir(save_dir):\\n raise ValueError('Save directory {} does not exist'.format(save_dir))\\n if sample_mode not in ['trajectories', 'samples']:\\n raise ValueError('Invalid sample mode: {}'.format(sample_mode))\\n\\n # Choose a default for num_samples if not specified.\\n if num_samples is None:\\n num_samples = 50 if sample_mode == 'trajectories' else 50000\\n\\n # Initialize the folders in the save directory.\\n iterations_dir = os.path.join(save_dir, 'iterations')\\n if not os.path.isdir(iterations_dir):\\n os.mkdir(iterations_dir)\\n logs_dir = os.path.join(save_dir, 'logs')\\n if agent.save_logs and not os.path.isdir(logs_dir):\\n os.mkdir(logs_dir)\\n\\n # Initialize results log file.\\n results_path = os.path.join(save_dir, 'results.txt')\\n open(results_path, 'w').close()\\n\\n # Initialize training variables.\\n np.random.seed(seed)\\n best_policy = copy.deepcopy(agent.policy)\\n best_perf = -1e8\\n train_curve = best_perf * np.ones(niter)\\n mean_pol_perf = 0.0\\n\\n # Prefix tensorboard logs with the job name.\\n # tb_logger = tensorboard.get_prefixed(job_name)\\n tb_logger = []\\n # print('Starting training for job: {}'.format(job_name))\\n\\n for i in range(niter):\\n print('.' * 80 + '\\\\nITERATION : {}'.format(i))\\n\\n if train_curve[i-1] > best_perf:\\n best_policy = copy.deepcopy(agent.policy)\\n best_perf = train_curve[i-1]\\n\\n stats = agent.train_step(\\n N=num_samples,\\n sample_mode=sample_mode,\\n gamma=gamma,\\n gae_lambda=gae_lambda,\\n num_cpu=num_cpu,\\n )\\n train_curve[i] = stats[0]\\n\\n if evaluation_rollouts is not None and evaluation_rollouts > 0:\\n print('Performing evaluation rollouts ........')\\n mean_pol_perf = _evaluation_rollout(agent, evaluation_rollouts, num_cpu)\\n if agent.save_logs:\\n agent.logger.log_kv('eval_score', mean_pol_perf)\\n\\n if i % save_freq == 0 and i > 0:\\n _save_policy(agent.policy, 'policy_{}'.format(i), iterations_dir)\\n _save_policy(agent.baseline, 'baseline_{}'.format(i), iterations_dir)\\n _save_policy(best_policy, 'best_policy', iterations_dir)\\n if agent.save_logs:\\n agent.logger.save_log(logs_dir)\\n make_train_plots(log=agent.logger.log, keys=plot_keys, save_loc=logs_dir)\\n\\n _log_performance(i, train_curve[i], mean_pol_perf, best_perf,\\n results_path, tb_logger)\\n if agent.save_logs:\\n print_data = sorted(filter(lambda v: np.asarray(v[1]).size == 1,\\n agent.logger.get_current_log().items()))\\n print(tabulate(print_data))\\n\\n # Save the final best policy.\\n _save_policy(best_policy, 'best_policy', iterations_dir)\\n if agent.save_logs:\\n agent.logger.save_log(logs_dir)\\n make_train_plots(log=agent.logger.log, keys=plot_keys, save_loc=logs_dir)\",\n \"def train_model(args: argparse.Namespace, hp: HParams, extension_architecture: str, timestamp: str,\\n logger: logging.Logger) -> None:\\n # 1. Check if we have to train a single tier or a complete model (with several tiers)\\n if args.tier is not None:\\n # 1.1 Argument tier was defined. Only that tier will be trained.\\n logging.info(f\\\"Training single tier of the model: Tier {args.tier}\\\")\\n\\n # 2. Setup tensorboard logging\\n # 2.1 Create tensorboard logs directory (tensorboard requires a different folder for each\\n # run of the model, in this case every run to train a tier) so we add the extension of the\\n # network's architecture of this run and the timestamp to identify it completely\\n tensorboard_dir = f\\\"{hp.logging.dir_log_tensorboard}{extension_architecture}_\\\" \\\\\\n f\\\"{timestamp}_tier{args.tier}\\\"\\n Path(tensorboard_dir).mkdir(parents=True, exist_ok=True)\\n # 2.2 Create tensorboard writer\\n tensorboardwriter = TensorboardWriter(hp, tensorboard_dir)\\n\\n # 3. Start training of the tier\\n train_tier(args, hp, args.tier, extension_architecture, timestamp, tensorboardwriter,\\n logger)\\n\\n tensorboardwriter.close()\\n\\n else:\\n # 1.2 Argument tier was not defined. Train all tiers of the model.\\n logging.info(\\\"Training all tiers of the model\\\")\\n\\n for tier in range(1, hp.network.n_tiers + 1):\\n # 2. Setup tensorboard logging (one for every tier)\\n # 2.1 Create tensorboard logs directory (tensorboard requires a different folder for\\n # each run of the model, in this case every run to train a tier) so we add the extension\\n # of the network's architecture of this run and the timestamp to identify it completely\\n tensorboard_dir = hp.logging.dir_log_tensorboard + extension_architecture \\\\\\n + f\\\"_{timestamp}_tier{tier}\\\"\\n Path(tensorboard_dir).mkdir(parents=True, exist_ok=True)\\n # 2.2 Create tensorboard writer\\n tensorboardwriter = TensorboardWriter(hp, tensorboard_dir)\\n\\n # 3. Start training of the tier\\n train_tier(args, hp, tier, extension_architecture, timestamp, tensorboardwriter, logger)\\n\\n tensorboardwriter.close()\\n del tensorboardwriter\",\n \"def start_training(self):\\n if self.task_env is None:\\n rospy.logfatal(\\\"No task environment found for training.\\\")\\n if self.agent is None:\\n rospy.logfatal(\\\"No agent found for training.\\\")\\n self.agent.start_training()\",\n \"def training(self) -> None:\\n self.compile_model()\\n self.train_epoch()\\n self.agent.save()\",\n \"def run(self) -> None:\\n self.model = self.trainer.train_model(self.model, self.data)\",\n \"def train(self, dataset, model_dir):\\n raise NotImplementedError\",\n \"def train_model(self):\\n self.logger.info('Loading the data...')\\n train_data = self.load_data(split=\\\"train\\\")\\n dev_data = self.load_data(split=\\\"dev\\\")\\n self.config.best_model = os.path.join(self.config.output_dir,\\\"best_model\\\")\\n self.logger.info('Training the model, outputdir=%s...,best_model=%s' % (self.config.output_dir,self.config.best_model))\\n\\n train_params = {\\n \\\"overwrite_output_dir\\\" : True,\\n \\\"reprocess_input_data\\\": True,\\n \\\"learning_rate\\\" : self.config.learning_rate,\\n \\\"num_train_epochs\\\" : self.config.num_train_epochs,\\n \\\"train_batch_size\\\" : self.config.train_batch_size,\\n \\\"eval_batch_size\\\" : self.config.eval_batch_size,\\n \\\"gradient_accumulation_steps\\\": self.config.gradient_accumulation_steps,\\n \\\"use_early_stopping\\\" : self.config.early_stopping,\\n \\\"fp16\\\" : False,\\n \\\"classification_report\\\" : True,\\n \\\"evaluate_during_training\\\" : True,\\n \\\"evaluate_during_training_verbose\\\" : True,\\n \\\"best_model_dir\\\": self.config.best_model,\\n \\\"save_model_every_epoch\\\" : self.config.save_model_every_epoch,\\n \\\"save_steps\\\" : self.config.save_steps,\\n \\\"save_optimizer_and_scheduler\\\" : self.config.save_optimizer_and_scheduler,\\n \\\"save_best_model\\\": True,\\n }\\n\\n ## train the model \\n self.model.train_model(\\n train_data,\\n eval_data=dev_data,\\n output_dir=self.config.output_dir,\\n show_running_loss=False,\\n args=train_params,\\n )\\n\\n ## backing up the config and create pointer to best model \\n with open(os.path.join(self.config.best_model,\\\"trainer_config.json\\\"),'w') as mconfig:\\n mconfig.write(json.dumps(self.config.__dict__))\\n self.config.existing_model = self.config.best_model\",\n \"def set_up_train(path_model_id='', config_names=['config.gin'], bindings=[]):\\n # inject config\\n utils_params.inject_gin(config_names, path_model_id=path_model_id,\\n bindings=bindings) # bindings=['train_and_eval.n_epochs = 3','train_and_eval.save_period = 1']\\n\\n # generate folder structures\\n run_paths = utils_params.gen_run_folder(path_model_id=path_model_id)\\n\\n # set loggers\\n utils_misc.set_loggers(run_paths['path_logs_train'], logging.INFO)\\n\\n # Define input pipeline depending on the type of training\\n logging.info('Setup input pipeline...')\\n train_ds, train_ds_info = gen_pipeline_train_baseline()\\n eval_ds, eval_ds_info = gen_pipeline_eval_baseline()\\n test_ds, test_info = gen_pipeline_test_baseline()\\n\\n # Define model\\n logging.info(\\\"Setup model...\\\")\\n model = model_fn.gen_model(n_classes=train_ds_info.features['label'].num_classes)\\n\\n # Train and eval\\n logging.info('Start training...')\\n results = train_baseline.train_and_eval_baseline(model, train_ds, train_ds_info, eval_ds, test_ds, run_paths)\\n\\n return results\",\n \"def train(self, absList, modelFilename):\\n pass\",\n \"def run_model(self):\\n hparams = self.hparams\\n\\n # Build the child graph\\n with tf.Graph().as_default(), tf.device(\\n '/cpu:0' if FLAGS.use_cpu else '/gpu:0'):\\n m, meval = self._build_models()\\n\\n # Figure out what epoch we are on\\n starting_epoch = self._calc_starting_epoch(m)\\n\\n # Run the validation error right at the beginning\\n valid_accuracy = self.eval_child_model(\\n meval, self.data_loader, 'val')\\n tf.logging.info('Before Training Epoch: {} Val Acc: {}'.format(\\n starting_epoch, valid_accuracy))\\n training_accuracy = None\\n\\n for curr_epoch in xrange(starting_epoch, hparams.num_epochs):\\n\\n # Run one training epoch\\n training_accuracy = self._run_training_loop(m, curr_epoch)\\n\\n valid_accuracy = self.eval_child_model(\\n meval, self.data_loader, 'val')\\n tf.logging.info('Epoch: {} Valid Acc: {}'.format(\\n curr_epoch, valid_accuracy))\\n\\n valid_accuracy, test_accuracy = self._compute_final_accuracies(\\n meval)\\n\\n tf.logging.info(\\n 'Train Acc: {} Valid Acc: {} Test Acc: {}'.format(\\n training_accuracy, valid_accuracy, test_accuracy))\",\n \"def train_model(n_estimators, max_depth, learning_rate, training_data, training_labels, test_data, test_labels, full_filename):\\n return sklearn_train_model(\\n _create_model(n_estimators, max_depth, learning_rate),\\n training_data, training_labels,\\n test_data, test_labels,\\n full_filename\\n )\",\n \"def do(self):\\n super().do()\\n logger.info(\\\"TrainPipeStep started...\\\")\\n records = self._get_current_step_records()\\n logger.debug(\\\"load pipestep records: {}\\\".format(records))\\n self.num_models = len(records)\\n self.num_epochs = self.num_models * TrainerConfig.epochs\\n self.update_status(Status.running)\\n self.master = create_master()\\n self._train_multi_models(records)\\n self.master.join()\\n ReportServer().output_step_all_records(step_name=self.task.step_name)\\n self.master.close()\\n ReportServer().backup_output_path()\\n self.update_status(Status.finished)\",\n \"def train_and_evaluate(\\n model_name: str,\\n job_log_dir: Optional[str],\\n multi_host_checkpointing: Optional[bool],\\n maybe_use_persistence_checkpointing: bool,\\n restore_checkpoint_dir: Optional[str],\\n restore_checkpoint_step: Optional[int],\\n eval_on_test: Optional[bool],\\n checkpoint_todelete_subdir: Optional[str] = None) -> None:\\n model_config = model_utils.get_model(model_name)()\\n _write_params_file(model_config, job_log_dir)\\n task_p = model_config.task()\\n\\n input_p = model_config.datasets()\\n # Note that we modify input params below with runtime information, therefore\\n # model_config.dataset() should not be called again as it won't have the\\n # correct runtime information populated.\\n for inp in input_p:\\n if not isinstance(inp, base_input.BaseInputParams):\\n raise ValueError('Expecting BaseInputParams from datasets(), got: '\\n f'{inp.ToText()}')\\n inp.num_infeed_hosts = jax.process_count()\\n inp.infeed_host_index = jax.process_index()\\n train_input_p = [v for v in input_p if v.is_training]\\n if len(train_input_p) != 1:\\n raise ValueError(\\n f'Expecting exactly one training split. Got `{len(train_input_p)}`.')\\n train_input_p = train_input_p[0]\\n logging.info('train_input_p=%s', train_input_p.ToText())\\n eval_input_p = None\\n if eval_on_test:\\n eval_input_p = [v for v in input_p if not v.is_training]\\n\\n checkpoint_type = checkpoints.retrieve_checkpoint_type(\\n multi_host_checkpointing, maybe_use_persistence_checkpointing, task_p)\\n\\n checkpoint_manager = _create_checkpoint_manager(model_name, task_p,\\n job_log_dir, checkpoint_type,\\n checkpoint_todelete_subdir)\\n\\n if task_p.model.device_mesh is not None:\\n train_and_evaluate_spmd_model(task_p, train_input_p, job_log_dir,\\n checkpoint_manager, checkpoint_type,\\n restore_checkpoint_dir,\\n restore_checkpoint_step, eval_input_p)\\n else:\\n train_and_evaluate_pmap(task_p, train_input_p, job_log_dir,\\n checkpoint_manager, restore_checkpoint_dir,\\n restore_checkpoint_step, eval_input_p)\",\n \"def train(\\n dir,\\n input_s3_dir,\\n output_s3_dir,\\n hyperparams_file,\\n ec2_type,\\n volume_size,\\n time_out,\\n docker_tag,\\n aws_role,\\n external_id,\\n base_job_name,\\n job_name,\\n use_spot_instances=False,\\n metric_names=None,\\n tags=None\\n):\\n config = _read_config(dir)\\n hyperparams_dict = _read_hyperparams_config(hyperparams_file) if hyperparams_file else None\\n sage_maker_client = sagemaker.SageMakerClient(config.aws_profile, config.aws_region, aws_role, external_id)\\n\\n image_name = config.image_name+':'+docker_tag\\n\\n return sage_maker_client.train(\\n image_name=image_name,\\n input_s3_data_location=input_s3_dir,\\n train_instance_count=1,\\n train_instance_type=ec2_type,\\n train_volume_size=volume_size,\\n train_max_run=time_out,\\n output_path=output_s3_dir,\\n hyperparameters=hyperparams_dict,\\n base_job_name=base_job_name,\\n job_name=job_name,\\n use_spot_instances=use_spot_instances,\\n tags=tags,\\n metric_names=metric_names\\n )\",\n \"def train(self, **kwargs):\\n self.solver.train(**kwargs)\",\n \"def train_setup(additional_arg_parser=None, args=None):\\n if args is None:\\n args = parse_input_arguments(additional_arg_parser)\\n if args.do_eval or args.do_test:\\n args.load_pretrained = True\\n if args.load_pretrained and args.pretrained_checkpoint == '':\\n raise ValueError('Must provide --pretrained_checkpoint when using --load_pretrained')\\n if args.eval_batch_size == 0:\\n args.eval_batch_size = args.train_batch_size\\n if args.load_pretrained:\\n args.save_dir = \\\"/\\\".join(args.pretrained_checkpoint.split('/')[:-1])\\n else:\\n args.save_dir = get_save_dir(args.save_dir, args.run_name)\\n if not os.path.exists(args.save_dir):\\n os.makedirs(args.save_dir)\\n args.start_epoch = 0\\n args.start_step = 0\\n\\n split_name = 'train' if args.do_train else 'validation' if args.do_eval else 'test'\\n logger = get_logger(args.save_dir, 'log_train')\\n\\n logger.info(\\\"local_rank: %d, node_index: %d, gpu_per_node: %d\\\"%(args.local_rank, args.node_index, args.gpu_per_node))\\n # Setup CUDA, GPU & distributed training\\n if args.local_rank == -1 or args.no_cuda:\\n device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() and not args.no_cuda else \\\"cpu\\\")\\n args.n_gpu = torch.cuda.device_count()\\n else: # Initializes the distributed backend which will take care of sychronizing nodes/GPUs\\n torch.cuda.set_device(args.local_rank)\\n device = torch.device(\\\"cuda\\\", args.local_rank)\\n torch.distributed.init_process_group(backend='nccl')\\n args.local_rank += args.node_index * args.gpu_per_node\\n args.n_gpu = 1\\n args.device = device\\n\\n logger.info(\\\"Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s, world size: %s\\\",\\n args.local_rank, device, args.n_gpu, bool(args.local_rank != -1), args.fp16,\\n torch.distributed.get_world_size() if args.local_rank != -1 else 1)\\n\\n set_seed(args)\\n\\n return args, logger\",\n \"def train(**kwargs):\\n print(\\\"train(**kwargs) - kwargs: %s\\\" % (kwargs)) if debug_model else ''\\n run_results = { \\\"status\\\": \\\"ok\\\",\\n \\\"sys_info\\\": [],\\n \\\"training\\\": [],\\n }\\n\\n\\n # Check if necessary local directories exist:\\n if not os.path.exists(cfg.Retina_LocalDataRecords):\\n print(\\\"[INFO] %s is not found locally, creating...\\\" % \\n cfg.Retina_LocalDataRecords)\\n os.makedirs(cfg.Retina_LocalDataRecords)\\n if not os.path.exists(cfg.Retina_LocalModelsServe):\\n print(\\\"[INFO] %s is not found locally, creating...\\\" % \\n cfg.Retina_LocalModelsServe)\\n os.makedirs(cfg.Retina_LocalModelsServe) \\n\\n # use the schema\\n schema = cfg.TrainArgsSchema()\\n # deserialize key-word arguments\\n train_args = schema.load(kwargs)\\n\\n # Take parameters defined via deepaas by a user\\n train_epochs = train_args['train_epochs']\\n batch_size = train_args['batch_size']\\n num_gpus = train_args['num_gpus']\\n epochs_between_evals = train_args['epochs_between_evals']\\n upload_back = train_args['upload_back']\\n if debug_model:\\n print(\\\"train_args:\\\", train_args)\\n print(type(train_args['train_epochs']), type(train_args['batch_size']))\\n print(\\\"Number of GPUs:\\\", train_args['num_gpus'], num_gpus)\\n\\n # from deep-nextcloud into the container\\n e1=time.time()\\n # check if retinopathy_tr.tfrecord.XX or retinopathy_va.tfrecord.XX files exist locally,\\n # if not -> download them from the RemoteStorage\\n train_files = 0\\n val_files = 0\\n for f in os.listdir(cfg.Retina_LocalDataRecords):\\n f_path = os.path.join(cfg.Retina_LocalDataRecords, f)\\n if (os.path.isfile(f_path) and cfg.Retina_TrainingData in f):\\n train_files += 1\\n if (os.path.isfile(f_path) and cfg.Retina_ValidationData in f):\\n val_files += 1\\n\\n if train_files < 100 or val_files < 20:\\n # Retina_RemoteDataRecords and Retina_LocalDataRecords are defined in config.py #vk\\n print(\\\"[INFO] Either training or validation files NOT found locally, download them from %s\\\" % \\n (cfg.Retina_RemoteDataRecords))\\n output, error = rclone_copy(cfg.Retina_RemoteDataRecords, cfg.Retina_LocalDataRecords)\\n if error:\\n message = \\\"[ERROR] training data not copied. rclone returned: \\\" + error\\n raise Exception(message)\\n\\n download_time=time.time()-e1\\n time.sleep(60)\\n\\n e2=time.time()\\n ### mimic retinopathy_main.py main()\\n # we first delete all the FLAGS\\n FLAGS = flags.FLAGS\\n #FLAGS.unparse_flags()\\n for name in list(FLAGS):\\n delattr(FLAGS, name)\\n\\n tf.logging.set_verbosity(tf.logging.INFO)\\n #tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.INFO)\\n # define default FLAGS for retinopathy_main and _run_loop\\n retimain.define_retinopathy_flags(batch_size=str(batch_size),\\n train_epochs=str(train_epochs),\\n num_gpus=str(num_gpus),\\n epochs_between_evals=str(epochs_between_evals))\\n\\n # build list of FLAG names and parse them via FLAGS(list)(IMPORTANT!) #vk\\n flag_names = []\\n for name in FLAGS:\\n flag_names.append(name)\\n\\n # According to the docs, actual parsing happens by either calling\\n # FLAGS(list_of_arguments) or by app.run()\\n FLAGS(flag_names)\\n # call actual training with the set flags\\n with logger.benchmark_context(flags.FLAGS):\\n graph_zip_path = retimain.run_retinopathy(flags.FLAGS)\\n\\n\\n try:\\n graph_zip_path = graph_zip_path.decode()\\n except (UnicodeDecodeError, AttributeError):\\n pass\\n graph_zip_path = graph_zip_path.rstrip()\\n\\n print(\\\"[INFO] Call of the training script returned: \\\", graph_zip_path)\\n training_time=time.time()-e2\\n time.sleep(60)\\n\\n e3=time.time()\\n # Retina_LocalModelsServe and Retina_RemoteModelsUpload are defined in config.py #vk\\n if(upload_back and os.path.exists(graph_zip_path)):\\n graph_zip_dir, graph_zip_name = os.path.split(graph_zip_path)\\n print(\\\"[INFO] Uploading {} to {} ...\\\".format(graph_zip_name, \\n cfg.Retina_RemoteModelsUpload))\\n output, error = rclone_copy(graph_zip_path,\\n os.path.join(cfg.Retina_RemoteModelsUpload, \\n graph_zip_name))\\n if error:\\n print(\\\"[ERROR] rclone returned: {}\\\".format(error))\\n else:\\n # if there is no error, remove zip file and the graph directory\\n savedmodel_dir, _ = os.path.splitext(graph_zip_name) # split name, ext\\n savedmodel_path = os.path.join(graph_zip_dir, savedmodel_dir)\\n ## Try to remove tree, if it exists\\n print(\\\"[INFO] Uploaded, deleting local {} and {}...\\\".format(graph_zip_path,\\n savedmodel_path))\\n os.remove(graph_zip_path) # remove zipped file\\n if os.path.exists(savedmodel_path):\\n shutil.rmtree(savedmodel_path) # remove corresponding directory\\n else:\\n print(\\\"[INFO] Saved model path, {}, doesn't exitst!\\\".format(\\n savedmodel_path)) \\n else:\\n print(\\\"[INFO] Created zip file of the graph, %s, was NOT uploaded!\\\" % graph_zip_path)\\n\\n upload_time=time.time()-e3\\n\\n train_files_size = 0\\n val_files_size = 0\\n for f in os.listdir(cfg.Retina_LocalDataRecords):\\n f_path = os.path.join(cfg.Retina_LocalDataRecords, f)\\n if (os.path.isfile(f_path) and cfg.Retina_TrainingData in f):\\n train_files_size += os.stat(f_path).st_size\\n if (os.path.isfile(f_path) and cfg.Retina_ValidationData in f):\\n val_files_size += os.stat(f_path).st_size\\n\\n message = {\\n \\\"Message\\\": \\\"Training finished!\\\",\\n \\\"Download time\\\": download_time, \\n \\\"Training time\\\": training_time,\\n \\\"Upload time\\\": upload_time,\\n \\\"Training set size\\\": convert_bytes(train_files_size), \\n \\\"Validation set size\\\": convert_bytes(val_files_size)\\n }\\n return message\",\n \"def train(model_name, batch_size, steps_per_epoch, epochs, validation_steps, \\n model_file=None, save_path=None):\\n \\n print(\\\"- Loading configuration...\\\")\\n if model_name in models_default_params:\\n default_params = models_default_params[model_name]\\n else:\\n print(\\\"Error: the model '{}' has not been implemented\\\".format(model_name))\\n return\\n custom_objects = default_params['custom_objects']\\n patch_size = default_params['patch_size']\\n if save_path is None:\\n save_path = default_params['default_path']\\n if os.path.isfile(save_path):\\n print(\\\"Warning: {} is an existing file and will be overwritten.\\\".format(save_path))\\n print(\\\"- Configuration loaded.\\\")\\n \\n print(\\\"- Loading datasets...\\\")\\n train_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Training/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Training/Labels/\\\",\\n patch_size = patch_size)\\n val_gen = preprocess.load_dataset(batch_size, x_directory = \\\"datasets/Potsdam/Validation/RGB/\\\",\\n y_directory = \\\"datasets/Potsdam/Validation/Labels/\\\",\\n patch_size = patch_size)\\n print(\\\"- Data loaded.\\\")\\n \\n print(\\\"- Initialising model...\\\")\\n if(model_file is not None): # Further train existing model\\n model = keras.models.load_model(model_file, custom_objects=custom_objects)\\n else: # Create new model\\n if model_name == 'fcn':\\n model = fcn.make_fcn_resnet((patch_size, patch_size, channels), nb_labels, \\n use_pretraining=False, freeze_base=False)\\n elif model_name == 'pspnet':\\n model = pspnet.build_pspnet(nb_classes=nb_labels, resnet_layers=50,\\n input_shape=patch_size)\\n elif model_name == 'mobilenetv2':\\n model = mobilenetv2.MobileNetv2((patch_size, patch_size, channels), nb_labels) \\n\\n model.compile(\\n optimizer = optimizers.Adam(lr = 0.00001),\\n loss = losses.categorical_crossentropy,\\n metrics = [metrics.categorical_accuracy]) \\n model.summary() \\n print(\\\"- Model initialised.\\\")\\n \\n tensorboard = callbacks.TensorBoard(log_dir='./logs')\\n csv_logger = callbacks.CSVLogger('logs/training.csv')\\n checkpoint = callbacks.ModelCheckpoint(filepath=checkpoint_path,\\n save_weights_only=True,\\n save_best_only=True)\\n \\n print(\\\"- Starting training.\\\")\\n model.fit_generator(\\n generator=train_gen,\\n steps_per_epoch=steps_per_epoch,\\n epochs=epochs,\\n validation_data=val_gen,\\n validation_steps=validation_steps,\\n # callbacks=[checkpoint, csv_logger]\\n )\\n print(\\\"- Training complete.\\\")\\n \\n model.save(save_path)\\n print(\\\"- Model saved to {}\\\".format(save_path))\",\n \"def train(args):\\n\\n log_header('Training network')\\n\\n train_retriever(args)\",\n \"def train(hparams, summary_dir, num_gpus, model_type, max_steps, save_step,\\n data_dir, num_targets, dataset, validate, seed, shuffled, shift,\\n pad, batch_size=128):\\n summary_dir += '/train/'\\n with tf.Graph().as_default():\\n # Build model\\n features = get_features('train', batch_size, num_gpus, data_dir,\\n num_targets, dataset, validate, evaluate=False,\\n seed=seed, shuffled=shuffled, shift=shift,\\n pad=pad)\\n model = models[model_type](hparams)\\n result, _ = model.multi_gpu(features, num_gpus)\\n # Print stats\\n param_stats = tf.profiler.profile(\\n tf.get_default_graph(),\\n options=tf.contrib.tfprof.model_analyzer.\\n TRAINABLE_VARS_PARAMS_STAT_OPTIONS)\\n sys.stdout.write('total_params: %d\\\\n' % param_stats.total_parameters)\\n writer = tf.summary.FileWriter(summary_dir)\\n run_experiment(load_training, summary_dir, writer, train_experiment,\\n model, result, max_steps, save_step)\\n writer.close()\",\n \"def run(job_path, model_path, metric):\\n\\n cmd = (f\\\"cd $NFFDIR/scripts/cp3d/train \\\"\\n f\\\"&& python train_parallel.py {job_path}\\\")\\n os.system(cmd)\\n best_score, best_epoch = parse_score(model_path, metric)\\n\\n return best_score\",\n \"def train_hyperopt(params):\\n lasagne.random.set_rng(RandomState(9859295))\\n\\n template_name = params.pop('template_name') \\n params = adjust_params_for_hyperopt(params)\\n \\n config_strings = create_config_strings(template_name)\\n config_objects = create_config_objects(config_strings)\\n templates, _ = create_templates_variants_from_config_objects(\\n config_objects)\\n \\n \\n processed_templates, params_without_template_params = process_templates(\\n templates, params)\\n final_params = process_parameters_by_templates(params_without_template_params, \\n processed_templates)\\n \\n # go to directory above this source-file\\n main_template_filename = os.path.dirname(os.path.abspath(os.path.dirname(\\n __file__)))\\n # then complete path to config\\n main_template_filename = os.path.join(main_template_filename, \\\"configs\\\", \\n \\\"eegnet_template.yaml\\\")\\n \\n with (open(main_template_filename, 'r')) as main_template_file:\\n main_template_str = main_template_file.read()\\n \\n \\n final_params['original_params'] = 'dummy'\\n train_str = Template(main_template_str).substitute(final_params)\\n \\n def do_not_load_constructor(loader, node):\\n return None\\n yaml.add_constructor(u'!DoNotLoad', do_not_load_constructor)\\n modified_train_str = train_str.replace('layers: ', 'layers: !DoNotLoad ')\\n train_dict = yaml_parse.load(modified_train_str) \\n dataset = train_dict['dataset'] \\n dataset.load()\\n dataset_provider = train_dict['dataset_provider']\\n \\n assert 'in_sensors' in train_str\\n assert 'in_rows' in train_str\\n assert 'in_cols' in train_str\\n \\n train_str = train_str.replace('in_sensors',\\n str(dataset.get_topological_view().shape[1]))\\n train_str = train_str.replace('in_rows',\\n str(dataset.get_topological_view().shape[2]))\\n train_str = train_str.replace('in_cols', \\n str(dataset.get_topological_view().shape[3]))\\n \\n train_dict = yaml_parse.load(train_str)\\n layers = train_dict['layers']\\n final_layer = layers[-1]\\n\\n # turn off debug/info logging\\n logging.getLogger(\\\"pylearn2\\\").setLevel(logging.WARN)\\n logging.getLogger(\\\"braindecode\\\").setLevel(logging.WARN)\\n exp = Experiment()\\n exp.setup(final_layer, dataset_provider, **train_dict['exp_args'])\\n exp.run()\\n final_misclass = exp.monitor_chans['test_misclass'][-1]\\n print(\\\"Result for\\\")\\n pprint(params)\\n print(\\\"Final Test misclass: {:5.4f}\\\".format(float(final_misclass)))\\n return final_misclass\",\n \"def train():\\n import training\\n\\n # Ensure output directories exist\\n os.makedirs(os.path.dirname(cfg.scaler_path), exist_ok=True)\\n os.makedirs(cfg.model_path, exist_ok=True)\\n os.makedirs(cfg.log_path, exist_ok=True)\\n\\n # Load (standardized) input data and target values\\n tr_x, tr_y, _ = _load_data(cfg.training_set, is_training=True)\\n val_x, val_y, _ = _load_data(cfg.validation_set)\\n\\n # Try to create reproducible results\\n np.random.seed(cfg.initial_seed)\\n\\n # Save free parameters to disk\\n utils.log_parameters(cfg.training, os.path.join(cfg.model_path,\\n 'parameters.json'))\\n\\n training.train(tr_x, tr_y, val_x, val_y)\",\n \"def start_training(self):\\n self.training = True\",\n \"def setup_training(model, batcher):\\r\\n train_dir = os.path.join(FLAGS.log_root, \\\"train\\\")\\r\\n if FLAGS.finetune:\\r\\n if not os.path.exists(train_dir):\\r\\n print (util.bcolors.OKGREEN + 'Copying See et al. pre-trained model (%s) to (%s) to be fine-tuned' % (os.path.join(FLAGS.pretrained_path, 'train'), train_dir) + util.bcolors.ENDC)\\r\\n os.makedirs(train_dir)\\r\\n files = glob.glob(os.path.join(os.path.join(FLAGS.pretrained_path, 'train'), \\\"*model*\\\"))\\r\\n files.extend(glob.glob(os.path.join(os.path.join(FLAGS.pretrained_path, 'train'), \\\"*checkpoint*\\\")))\\r\\n for file in files:\\r\\n if os.path.isfile(file):\\r\\n shutil.copy2(file, train_dir)\\r\\n if not os.path.exists(train_dir): os.makedirs(train_dir)\\r\\n\\r\\n model.build_graph() # build the graph\\r\\n if FLAGS.convert_to_coverage_model:\\r\\n assert FLAGS.coverage, \\\"To convert your non-coverage model to a coverage model, run with convert_to_coverage_model=True and coverage=True\\\"\\r\\n convert_to_coverage_model()\\r\\n if FLAGS.restore_best_model:\\r\\n restore_best_model()\\r\\n saver = tf.train.Saver(max_to_keep=3) # keep 3 checkpoints at a time\\r\\n\\r\\n sv = tf.train.Supervisor(logdir=train_dir,\\r\\n is_chief=True,\\r\\n saver=saver,\\r\\n summary_op=None,\\r\\n save_summaries_secs=60, # save summaries for tensorboard every 60 secs\\r\\n save_model_secs=60, # checkpoint every 60 secs\\r\\n global_step=model.global_step)\\r\\n summary_writer = sv.summary_writer\\r\\n logging.info(\\\"Preparing or waiting for session...\\\")\\r\\n sess_context_manager = sv.prepare_or_wait_for_session(config=util.get_config())\\r\\n logging.info(\\\"Created session.\\\")\\r\\n try:\\r\\n run_training(model, batcher, sess_context_manager, sv, summary_writer) # this is an infinite loop until interrupted\\r\\n except KeyboardInterrupt:\\r\\n logging.info(\\\"Caught keyboard interrupt on worker. Stopping supervisor...\\\")\\r\\n sv.stop()\",\n \"def train(self, training_data, cfg, **kwargs):\\n pass\",\n \"def train(self):\\n self.log(f\\\"{self.cur_file_path}\\\\t\\\\tInfo: train method invoked!\\\")\\n self.log(f\\\"{self.cur_file_path}\\\\t\\\\tInfo: training {self.model.__class__.__name__} model!\\\")\\n\\n self.model.fit(self.trainX, self.trainY)\",\n \"def train(self):\\n\\t\\tself.model.fit(self.training_data, self.training_labels)\",\n \"def train(self, training_steps=10):\",\n \"def train_next_model(self, wait=True, input_data_s3_prefix=None, input_model_id=None):\\n # Sync experiment state if required\\n self._sync_experiment_state_with_ddb()\\n\\n # use 'last_trained_model_id' by default as input model for next training\\n if input_model_id is None and self.experiment_record._last_trained_model_id is not None:\\n logger.info(\\n f\\\"Use last trained model {self.experiment_record._last_trained_model_id} \\\"\\n \\\"as pre-trained model for training\\\"\\n )\\n\\n input_model_id = self.experiment_record._last_trained_model_id\\n\\n if input_model_id != self.experiment_record._last_trained_model_id:\\n # No deployment if the given model is not ready\\n if not self._check_if_model_ready(input_model_id):\\n return\\n\\n # experiment only allows one training job at a time,\\n # validate no other training request is in progress\\n if (\\n self.experiment_record._training_state is not None\\n and self.experiment_record._training_state.endswith(\\\"ING\\\")\\n ):\\n logger.error(\\n f\\\"A training request with model id '{self.experiment_record._next_model_to_train_id}' \\\"\\n f\\\"was in the state of '{self.experiment_record._training_state}'. \\\"\\n \\\"Please wait until the training job is finished.\\\"\\n )\\n raise InvalidUsageException(\\n \\\"Please wait for old Training Job to Complete before requesting a new one!\\\"\\n )\\n else:\\n # update next_model_to_train_id and training state\\n next_model_to_train_id = ModelManager.name_next_model(experiment_id=self.experiment_id)\\n\\n logger.info(f\\\"Starting training job for ModelId '{next_model_to_train_id}''\\\")\\n\\n self.exp_db_client.update_experiment_next_model_to_train_id(\\n self.experiment_id, next_model_to_train_id\\n )\\n self.exp_db_client.update_experiment_training_state(\\n self.experiment_id, TrainingState.PENDING\\n )\\n\\n manifest_file_path = None\\n if isinstance(input_data_s3_prefix, list):\\n # generate manifest file and upload to s3 when having multiple inputs\\n manifest_file_path = self._generate_manifest(input_data_s3_prefix)\\n\\n try:\\n self.next_model_to_train = ModelManager(\\n model_db_client=self.model_db_client,\\n experiment_id=self.experiment_id,\\n model_id=next_model_to_train_id,\\n image=self.image,\\n role=self.resource_manager.iam_role_arn,\\n instance_config=self.resource_manager.training_fleet_config,\\n boto_session=self.boto_session,\\n algor_config=self.algor_config,\\n )\\n self.next_model_to_train.fit(\\n wait=wait,\\n input_model_id=input_model_id,\\n input_data_s3_prefix=input_data_s3_prefix,\\n manifest_file_path=manifest_file_path,\\n logs=wait,\\n )\\n except Exception as e:\\n logger.error(e)\\n pass\\n\\n # wait until exp ddb table updated\\n if self.local_mode or wait:\\n trained_state = (\\n self.experiment_record._training_state == TrainingState.TRAINED\\n and self.experiment_record._last_trained_model_id == next_model_to_train_id\\n and self.experiment_record._next_model_to_train_id is None\\n )\\n num_retries = 0\\n\\n while not trained_state:\\n # Sync experiment state if required\\n self._sync_experiment_state_with_ddb()\\n logger.debug(\\\"Waiting for experiment table training status to be updated...\\\")\\n time.sleep(2 * (2 ** num_retries))\\n trained_state = (\\n self.experiment_record._training_state == TrainingState.TRAINED\\n and self.experiment_record._last_trained_model_id == next_model_to_train_id\\n and self.experiment_record._next_model_to_train_id is None\\n )\\n num_retries += 1\\n if num_retries >= 5:\\n raise UnhandledWorkflowException(\\n f\\\"Training job '{self.experiment_record._next_model_to_train_id}' \\\"\\n f\\\"was in state of '{self.experiment_record._training_state}'. Expected it to be TRAINED.\\\"\\n )\\n if (\\n self.experiment_record._training_state == TrainingState.FAILED\\n or self.experiment_record._training_state == TrainingState.STOPPED\\n ):\\n raise SageMakerTrainingJobException(\\n f\\\"Training job '{self.experiment_record._next_model_to_train_id}' \\\"\\n f\\\"ended in state of '{self.experiment_record._training_state}'. Please check Sagemaker logs for \\\"\\n \\\"more information.\\\"\\n )\",\n \"def bulk_train(self):\\n logger.info(\\\"collecting subfolders - relations\\\")\\n relations = self.collect_subfolders(self.input_dir)\\n logger.info(\\\"relations - {}\\\".format(relations))\\n\\n execution_times = []\\n\\n for rel, rel_path in tqdm(relations.items(), desc=\\\"relations\\\"):\\n logger.info(\\\"collecting training files from {}\\\".format(rel_path))\\n tr_files = self.collect_files(rel_path, self.regexp_train)\\n hyper_params = self.get_hyperparams()\\n hyper_params['graph'] = tr_files\\n\\n output_folder = os.path.join(self.output_dir, rel)\\n if not os.path.exists(output_folder):\\n logger.info(\\\"creating {} (did not exist)\\\".format(output_folder))\\n os.makedirs(output_folder)\\n\\n for params in tqdm(ParameterGrid(hyper_params), desc=\\\"training embedding\\\"):\\n logger.info(\\\"hyperparams: {}\\\".format(params))\\n train_file = params['graph']\\n model_name = self.compute_model_name(params, output_folder)\\n logger.info('training starspace model \\\"{}\\\" from file \\\"{}\\\"'.format(\\n model_name, train_file))\\n external_output, delta = self.call_starspace(params, train_file, model_name)\\n logger.info(\\\"executed in {:0.2f}s\\\".format(delta))\\n\\n logger.info(\\\"external command output logged in {}\\\".format(self.external_log))\\n if not os.path.exists(self.output_dir):\\n logger.info(\\\"creating {} (did not exist)\\\".format(self.output_dir))\\n os.makedirs(self.output_dir)\\n\\n with open(self.external_log, 'a') as f:\\n f.write(external_output)\\n\\n execution_times.append(dict({ 'time': delta }, **params))\\n \\n return execution_times\",\n \"def train_model(data_dir, rows):\\n X, y = read_vectorized_features(data_dir, rows)\\n\\n # Set params\\n # Scores ~0.784 (without tuning and early stopping)\\n params = {'boosting_type': 'gbdt',\\n 'max_depth' : -1,\\n 'objective': 'binary',\\n 'nthread': 3, # Updated from nthread\\n 'num_leaves': 64,\\n 'learning_rate': 0.05,\\n 'max_bin': 512,\\n 'subsample_for_bin': 200,\\n 'subsample': 1,\\n 'subsample_freq': 1,\\n 'colsample_bytree': 0.8,\\n 'reg_alpha': 5,\\n 'reg_lambda': 10,\\n 'min_split_gain': 0.5,\\n 'min_child_weight': 1,\\n 'min_child_samples': 5,\\n 'scale_pos_weight': 1,\\n 'num_class' : 1,\\n 'metric' : 'binary_error'}\\n\\n # Create parameters to search\\n gridParams = {\\n 'learning_rate': [0.15, 0.2, 0.25, 0.3], #default = 0.1\\n 'n_estimators': [40],\\n 'num_leaves': [6,8,12,16],\\n 'boosting_type' : ['gbdt'],\\n 'objective' : ['binary'],\\n 'random_state' : [501], # Updated from 'seed'\\n 'colsample_bytree' : [0.65, 0.66],\\n 'subsample' : [0.7,0.75],\\n 'reg_alpha' : [1,1.2],\\n 'reg_lambda' : [1,1.2,1.4],\\n }\\n\\n # Create classifier to use. Note that parameters have to be input manually\\n # not as a dict!\\n mdl = lgb.LGBMClassifier(boosting_type= 'gbdt',\\n objective = 'binary',\\n n_jobs = 3, # Updated from 'nthread'\\n silent = True,\\n max_depth = params['max_depth'],\\n max_bin = params['max_bin'],\\n subsample_for_bin = params['subsample_for_bin'],\\n subsample = params['subsample'],\\n subsample_freq = params['subsample_freq'],\\n min_split_gain = params['min_split_gain'],\\n min_child_weight = params['min_child_weight'],\\n min_child_samples = params['min_child_samples'],\\n scale_pos_weight = params['scale_pos_weight'])\\n\\n # Create the grid\\n grid = GridSearchCV(mdl, gridParams,\\n verbose=0,\\n cv=4,\\n n_jobs=2)\\n # train\\n grid.fit(X, y)\\n print(grid.best_params_)\\n print(grid.best_score_)\\n\\n\\n # train\\n lgbm_dataset = lgb.Dataset(X, y)\\n lgbm_model = lgb.train({\\\"application\\\": \\\"binary\\\"}, lgbm_dataset)\\n\\n return lgbm_model\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--identifier\\\", required=True,\\n help=\\\"A short name/identifier for your experiment, e.g. 'ex42b'.\\\")\\n args = parser.parse_args()\\n\\n train(args)\",\n \"def trainModel( self, featureTrain, classTrain):\",\n \"def train(cfg):\\n # Set up environment.\\n distributed.init_distributed_training(cfg)\\n\\n # Set random seed from configs.\\n np.random.seed(cfg.RNG_SEED)\\n torch.manual_seed(cfg.RNG_SEED)\\n\\n # Print config.\\n if distributed.is_master_proc():\\n print(\\\"Train with config:\\\")\\n print(pprint.pformat(cfg))\\n\\n # Create train and val loaders.\\n train_dataset = PanopticNarrativeGroundingDataset(cfg, cfg.DATA.TRAIN_SPLIT, train=True)\\n train_loader = DataLoader(\\n train_dataset,\\n batch_size=int(cfg.TRAIN.BATCH_SIZE / max(1, cfg.NUM_GPUS)),\\n shuffle=(False if cfg.NUM_GPUS > 1 else True),\\n sampler=(DistributedSampler(train_dataset) if cfg.NUM_GPUS > 1 else None),\\n num_workers=cfg.DATA_LOADER.NUM_WORKERS,\\n pin_memory=cfg.DATA_LOADER.PIN_MEMORY\\n )\\n if cfg.DATA.VAL_SPLIT is not None:\\n val_dataset = PanopticNarrativeGroundingDataset(cfg, cfg.DATA.VAL_SPLIT, train=False)\\n val_loader = DataLoader(\\n val_dataset,\\n batch_size=(1 if cfg.NUM_GPUS > 1 else cfg.TRAIN.BATCH_SIZE),\\n shuffle=False,\\n sampler=(DistributedSampler(val_dataset) if cfg.NUM_GPUS > 1 else None),\\n num_workers=cfg.DATA_LOADER.NUM_WORKERS,\\n pin_memory=cfg.DATA_LOADER.PIN_MEMORY\\n )\\n\\n # Build the model and print model statistics.\\n # Use cuda if available\\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\\n # Construct the model\\n model = PanopticNarrativeGroundingBaseline(cfg, device=device)\\n # Determine the GPU used by the current process\\n cur_device = torch.cuda.current_device()\\n # Transfer the model to the current GPU device\\n model = model.cuda(device=cur_device)\\n # Use multi-process data parallel model in the multi-gpu setting\\n if cfg.NUM_GPUS > 1:\\n # Make model replica operate on the current device\\n model = torch.nn.parallel.DistributedDataParallel(\\n module=model, device_ids=[cur_device], output_device=cur_device,\\n find_unused_parameters=True\\n )\\n if cfg.LOG_MODEL_INFO and distributed.is_master_proc():\\n print(\\\"Model:\\\\n{}\\\".format(model))\\n print(\\\"Params: {:,}\\\".format(np.sum([p.numel() for p in model.parameters()]).item()))\\n print(\\\"Mem: {:,} MB\\\".format(torch.cuda.max_memory_allocated() / 1024 ** 3))\\n print(\\\"nvidia-smi\\\")\\n os.system(\\\"nvidia-smi\\\")\\n\\n if cfg.MODEL.BERT_FREEZE:\\n if cfg.NUM_GPUS > 1:\\n for param in model.module.bert_encoder.model.bert.encoder.layer.parameters():\\n param.requires_grad = False\\n else:\\n for param in model.bert_encoder.model.bert.encoder.layer.parameters():\\n param.requires_grad = False\\n\\n # Construct the optimizer.\\n def optimizer_wrapper(Optim, **kwargs):\\n def init_func(model):\\n return Optim(model.parameters(), **kwargs)\\n return init_func\\n\\n optimizers = {\\n \\\"adamax\\\": (\\n optimizer_wrapper(optim.Adamax, lr=cfg.SOLVER.BASE_LR),\\n lambda optim: optim.param_groups[0][\\\"lr\\\"],\\n ),\\n \\\"adam\\\": (\\n optimizer_wrapper(optim.Adam, lr=cfg.SOLVER.BASE_LR),\\n lambda optim: optim.param_groups[0][\\\"lr\\\"],\\n ),\\n \\\"sgd\\\": (\\n optimizer_wrapper(optim.SGD, lr=cfg.SOLVER.BASE_LR, momentum=0.9),\\n lambda optim: optim.param_groups[0][\\\"lr\\\"],\\n ),\\n }\\n\\n if cfg.SOLVER.OPTIMIZING_METHOD not in optimizers:\\n cfg.SOLVER.OPTIMIZING_METHOD = 'adam'\\n if distributed.is_master_proc():\\n print(\\\"{0} not defined in available optimizer list, fallback to Adam\\\")\\n\\n optimizer, _ = optimizers[cfg.SOLVER.OPTIMIZING_METHOD]\\n optimizer = optimizer(model)\\n if distributed.is_master_proc():\\n print('optimizer: {}'.format(optimizer))\\n\\n # Load a checkpoint to resume training if applicable.\\n checkpoint_path = osp.join(cfg.OUTPUT_DIR, 'checkpoint.pth')\\n if osp.exists(checkpoint_path):\\n if distributed.is_master_proc():\\n print('Resuming training: loading model from: {0}'.format(checkpoint_path))\\n checkpoint = torch.load(checkpoint_path, map_location=\\\"cpu\\\")\\n if cfg.NUM_GPUS > 1:\\n model.module.load_state_dict(checkpoint['model_state'])\\n else:\\n model.load_state_dict(checkpoint['model_state'])\\n optimizer.load_state_dict(checkpoint['optimizer_state'])\\n start_epoch = checkpoint['epoch'] + 1\\n model_final_path = osp.join(cfg.OUTPUT_DIR, 'model_final.pth')\\n if osp.exists(model_final_path):\\n model_final = torch.load(model_final_path)\\n best_val_score = model_final['accuracy']\\n else:\\n best_val_score = None\\n elif osp.exists(cfg.TRAIN.CHECKPOINT_FILE_PATH):\\n if distributed.is_master_proc():\\n print('Loading model from: {0}'.format(cfg.TRAIN.CHECKPOINT_FILE_PATH))\\n checkpoint = torch.load(cfg.TRAIN.CHECKPOINT_FILE_PATH, map_location=\\\"cpu\\\")\\n if cfg.NUM_GPUS > 1:\\n model.module.load_state_dict(checkpoint['model_state'])\\n else:\\n model.load_state_dict(checkpoint['model_state'])\\n start_epoch, best_val_score = 0, None\\n else: \\n start_epoch, best_val_score = 0, None\\n\\n # Define loss function\\n loss_function = nn.BCEWithLogitsLoss()\\n\\n if distributed.is_master_proc():\\n print('Train begins...')\\n if cfg.TRAIN.EVAL_FIRST:\\n accuracy = evaluate(val_loader, model, -1, cfg)\\n if best_val_score is None or accuracy > best_val_score:\\n best_val_score = accuracy\\n try:\\n # Perform the training loop\\n for epoch in range(start_epoch, cfg.SOLVER.MAX_EPOCH):\\n epoch_start_time = time.time()\\n # Shuffle the dataset\\n if cfg.NUM_GPUS > 1:\\n train_loader.sampler.set_epoch(epoch)\\n # Train for one epoch\\n train_loss = train_epoch(train_loader, model, optimizer, loss_function, epoch, cfg)\\n accuracy = evaluate(val_loader, model, epoch, cfg) \\n\\n if distributed.is_master_proc():\\n # Save best model in the validation set\\n if best_val_score is None or accuracy > best_val_score:\\n best_val_score = accuracy\\n model_final_path = osp.join(cfg.OUTPUT_DIR, 'model_final.pth')\\n model_final = {\\n \\\"epoch\\\": epoch,\\n \\\"model_state\\\": model.state_dict(),\\n \\\"optimizer_state\\\": optimizer.state_dict(),\\n \\\"accuracy\\\": accuracy\\n }\\n torch.save(model_final, model_final_path)\\n print('-' * 89)\\n print('| end of epoch {:3d} | time: {:5.2f}s '\\n '| epoch loss {:.6f} |'.format(\\n epoch, time.time() - epoch_start_time, train_loss))\\n print('-' * 89)\\n except KeyboardInterrupt:\\n if distributed.is_master_proc():\\n print('-' * 89)\\n print('Exiting from training early')\",\n \"def train(self):\\n # setup model\\n self.createModel()\\n self.setGenerators()\\n self.buildCallbacks()\\n self.printParameters()\\n \\n # train model\\n _ = self.model.fit_generator(\\n generator = self.trainGen,\\n validation_data = self.validateGen,\\n steps_per_epoch = self.steps_per_epoch,\\n validation_steps = self.validation_steps,\\n epochs = self.epochs,\\n use_multiprocessing = True,\\n callbacks = self.callbacks)\\n # clear save paths to avoid overwriting accidentaly\\n self.saveName = None\",\n \"def train(self):\\n self.ae_train(self.net0, self.ae0_optimizer, self.train0_loader, self.val_loader, name='Net0')\\n self.ae_train(self.net1, self.ae1_optimizer, self.train1_loader, self.val_loader, name='Net1')\\n self.ae_train(self.net2, self.ae2_optimizer, self.train2_loader, self.val_loader, name='Net2')\\n\\n self.classifier_train(self.net0, self.optimizer0, self.train0_loader, self.val_loader, name='Net0')\\n self.classifier_train(self.net1, self.optimizer1, self.train1_loader, self.val_loader, name='Net1')\\n self.classifier_train(self.net2, self.optimizer2, self.train2_loader, self.val_loader, name='Net2')\",\n \"def trigger_batch_job(parent_batch_id, job_input, job_params):\\n job_name = job_params[\\\"jobName\\\"]\\n job_modality = job_params[\\\"jobModality\\\"]\\n\\n batch_id = f\\\"{parent_batch_id}-{job_name}\\\"\\n\\n output_path = (\\n f\\\"s3://{batch_processing_bucket_name}/batch_manifests/{job_modality}/{batch_id}/output\\\"\\n )\\n\\n # If a label category file wasn't provided as API input, use the previous\\n # job's label category file.\\n label_category_config_uri = job_input.label_category_s3_uri\\n if \\\"labelCategoryConfigS3Uri\\\" in job_params:\\n label_category_config_uri = job_params[\\\"labelCategoryConfigS3Uri\\\"]\\n\\n # batch_job_input_data = event[\\\"batch_job_input\\\"]\\n labeling_job_request = construct_labeling_job_input(\\n parent_batch_id=parent_batch_id,\\n input_manifest_url=job_input.input_manifest_s3_uri,\\n audit_label_attribute_name=job_input.label_attribute_name,\\n label_category_config_uri=label_category_config_uri,\\n job_params=job_params,\\n output_path=output_path,\\n )\\n\\n sagemaker.create_labeling_job(**labeling_job_request)\\n s3_output_path = f\\\"{output_path}/{job_name}/manifests/output/output.manifest\\\"\\n\\n db.insert_job_level_metadata(\\n parent_batch_id=parent_batch_id,\\n batch_id=batch_id,\\n batch_status=BatchStatus.WAIT_FOR_SMGT_RESPONSE,\\n labeling_job_name=job_name,\\n label_attribute_name=labeling_job_request[\\\"LabelAttributeName\\\"],\\n label_category_s3_uri=labeling_job_request[\\\"LabelCategoryConfigS3Uri\\\"],\\n job_input_s3_uri=labeling_job_request[\\\"InputConfig\\\"][\\\"DataSource\\\"][\\\"S3DataSource\\\"][\\n \\\"ManifestS3Uri\\\"\\n ],\\n job_output_s3_uri=s3_output_path,\\n )\",\n \"def _train_model(\\n self,\\n dataset: DatasetEntity,\\n ):\\n logger.info(\\\"init data cfg.\\\")\\n self._data_cfg = ConfigDict(data=ConfigDict())\\n\\n for cfg_key, subset in zip(\\n [\\\"train\\\", \\\"val\\\", \\\"unlabeled\\\"],\\n [Subset.TRAINING, Subset.VALIDATION, Subset.UNLABELED],\\n ):\\n subset = get_dataset(dataset, subset)\\n if subset and self._data_cfg is not None:\\n self._data_cfg.data[cfg_key] = ConfigDict(\\n otx_dataset=subset,\\n labels=self._labels,\\n )\\n\\n self._is_training = True\\n\\n self._init_task()\\n\\n cfg = self.configure(True, None)\\n logger.info(\\\"train!\\\")\\n\\n timestamp = time.strftime(\\\"%Y%m%d_%H%M%S\\\", time.localtime())\\n\\n # Environment\\n logger.info(f\\\"cfg.gpu_ids = {cfg.gpu_ids}, distributed = {cfg.distributed}\\\")\\n env_info_dict = collect_env()\\n env_info = \\\"\\\\n\\\".join([(f\\\"{k}: {v}\\\") for k, v in env_info_dict.items()])\\n dash_line = \\\"-\\\" * 60 + \\\"\\\\n\\\"\\n logger.info(f\\\"Environment info:\\\\n{dash_line}{env_info}\\\\n{dash_line}\\\")\\n\\n # Data\\n datasets = [build_dataset(cfg.data.train)]\\n\\n if self._train_type == TrainType.Semisupervised:\\n # forward the knowledge of num iters per epoch to model for filter loss\\n bs_per_gpu = cfg.data.train_dataloader[\\\"samples_per_gpu\\\"]\\n actual_bs = bs_per_gpu * torch.distributed.get_world_size() if cfg.distributed else bs_per_gpu\\n cfg.model.num_iters_per_epoch = math.ceil(len(datasets[0]) / actual_bs)\\n\\n # FIXME: Currently segmentor does not support multi batch evaluation.\\n # For the Self-SL case, there is no val data. So, need to check the\\n\\n if \\\"val\\\" in cfg.data and \\\"val_dataloader\\\" in cfg.data:\\n cfg.data.val_dataloader[\\\"samples_per_gpu\\\"] = 1\\n\\n # Target classes\\n if \\\"task_adapt\\\" in cfg:\\n target_classes = cfg.task_adapt.final\\n else:\\n target_classes = datasets[0].CLASSES\\n\\n # Metadata\\n meta = dict()\\n meta[\\\"env_info\\\"] = env_info\\n meta[\\\"seed\\\"] = cfg.seed\\n meta[\\\"exp_name\\\"] = cfg.work_dir\\n if cfg.checkpoint_config is not None:\\n cfg.checkpoint_config.meta = dict(\\n mmseg_version=__version__ + get_git_hash()[:7],\\n CLASSES=target_classes,\\n )\\n\\n # Model\\n model = self.build_model(cfg, fp16=cfg.get(\\\"fp16\\\", False), is_training=self._is_training)\\n model.train()\\n model.CLASSES = target_classes\\n\\n if cfg.distributed:\\n convert_sync_batchnorm(model)\\n\\n validate = bool(cfg.data.get(\\\"val\\\", None))\\n\\n if self._hyperparams.learning_parameters.auto_adapt_batch_size != BatchSizeAdaptType.NONE:\\n train_func = partial(train_segmentor, meta=deepcopy(meta), model=deepcopy(model), distributed=False)\\n adapt_batch_size(\\n train_func,\\n cfg,\\n datasets,\\n isinstance(self, NNCFBaseTask), # nncf needs eval hooks\\n not_increase=(self._hyperparams.learning_parameters.auto_adapt_batch_size == BatchSizeAdaptType.SAFE),\\n )\\n\\n train_segmentor(\\n model,\\n datasets,\\n cfg,\\n distributed=cfg.distributed,\\n validate=validate,\\n timestamp=timestamp,\\n meta=meta,\\n )\\n\\n # Save outputs\\n output_ckpt_path = os.path.join(cfg.work_dir, \\\"latest.pth\\\")\\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \\\"best_mDice_*.pth\\\"))\\n if len(best_ckpt_path) > 0:\\n output_ckpt_path = best_ckpt_path[0]\\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \\\"best_mIoU_*.pth\\\"))\\n if len(best_ckpt_path) > 0:\\n output_ckpt_path = best_ckpt_path[0]\\n return dict(\\n final_ckpt=output_ckpt_path,\\n )\",\n \"def main(args):\\n\\n shared_policy_net = build_policy_net(args).share_memory()\\n shared_value_net = build_value_net(args).share_memory()\\n\\n start_training_processes(\\n args,\\n shared_policy_net,\\n shared_value_net,\\n )\",\n \"def train(parser):\\n cli_args = add_all_args(parser, TRAINING)\\n if not cli_args.train_tfrecord and not cli_args.valid_tfrecord:\\n assert (\\n cli_args.relative_labels or cli_args.xml_labels_folder\\n ), 'No labels provided: specify --relative-labels or --xml-labels-folder'\\n if cli_args.augmentation_preset:\\n assert (\\n preset := cli_args.augmentation_preset\\n ) in AUGMENTATION_PRESETS, f'Invalid augmentation preset {preset}'\\n trainer = Trainer(\\n input_shape=cli_args.input_shape,\\n model_configuration=cli_args.model_cfg,\\n classes_file=cli_args.classes,\\n train_tf_record=cli_args.train_tfrecord,\\n valid_tf_record=cli_args.valid_tfrecord,\\n max_boxes=cli_args.max_boxes,\\n iou_threshold=cli_args.iou_threshold,\\n score_threshold=cli_args.score_threshold,\\n image_folder=cli_args.image_folder,\\n )\\n trainer.train(\\n epochs=cli_args.epochs,\\n batch_size=cli_args.batch_size,\\n learning_rate=cli_args.learning_rate,\\n new_dataset_conf={\\n 'dataset_name': (d_name := cli_args.dataset_name),\\n 'relative_labels': cli_args.relative_labels,\\n 'test_size': cli_args.test_size,\\n 'voc_conf': cli_args.voc_conf,\\n 'augmentation': bool((preset := cli_args.augmentation_preset)),\\n 'sequences': AUGMENTATION_PRESETS.get(preset),\\n 'aug_workers': cli_args.workers,\\n 'aug_batch_size': cli_args.process_batch_size,\\n },\\n dataset_name=d_name,\\n weights=cli_args.weights,\\n evaluate=cli_args.evaluate,\\n merge_evaluation=cli_args.merge_evaluation,\\n evaluation_workers=cli_args.workers,\\n shuffle_buffer=cli_args.shuffle_buffer,\\n min_overlaps=cli_args.min_overlaps,\\n display_stats=cli_args.display_stats,\\n plot_stats=cli_args.plot_stats,\\n save_figs=cli_args.save_figs,\\n clear_outputs=cli_args.clear_output,\\n n_epoch_eval=cli_args.n_eval,\\n )\",\n \"def _train_model(self):\\n self.experiment = EpisodicExperiment(self.task, self.agent)\\n n_epochs = int(self.rl_params.n_training_episodes / self.rl_params.n_episodes_per_epoch)\\n logger.debug(\\\"Fitting user model over {} epochs, each {} episodes, total {} episodes.\\\"\\n .format(n_epochs, self.rl_params.n_episodes_per_epoch, n_epochs*self.rl_params.n_episodes_per_epoch))\\n for i in range(n_epochs):\\n logger.debug(\\\"RL epoch {}\\\".format(i))\\n self.experiment.doEpisodes(self.rl_params.n_episodes_per_epoch)\\n self.agent.learn()\\n self.agent.reset() # reset buffers\",\n \"def main(_) -> None:\\n params = train_utils.parse_configuration(FLAGS)\\n mode = FLAGS.mode\\n model_dir = FLAGS.model_dir\\n if 'train' in FLAGS.mode:\\n # Pure eval modes do not output yaml files. Otherwise continuous eval job\\n # may race against the train job for writing the same file.\\n train_utils.serialize_config(params, model_dir)\\n\\n if FLAGS.seed is not None:\\n logging.info('Setting tf seed.')\\n tf.random.set_seed(FLAGS.seed)\\n\\n task = RankingTask(\\n params=params.task,\\n optimizer_config=params.trainer.optimizer_config,\\n logging_dir=model_dir,\\n steps_per_execution=params.trainer.steps_per_loop,\\n name='RankingTask')\\n\\n enable_tensorboard = params.trainer.callbacks.enable_tensorboard\\n\\n strategy = distribute_utils.get_distribution_strategy(\\n distribution_strategy=params.runtime.distribution_strategy,\\n all_reduce_alg=params.runtime.all_reduce_alg,\\n num_gpus=params.runtime.num_gpus,\\n tpu_address=params.runtime.tpu)\\n\\n with strategy.scope():\\n model = task.build_model()\\n\\n def get_dataset_fn(params):\\n return lambda input_context: task.build_inputs(params, input_context)\\n\\n train_dataset = None\\n if 'train' in mode:\\n train_dataset = strategy.distribute_datasets_from_function(\\n get_dataset_fn(params.task.train_data),\\n options=tf.distribute.InputOptions(experimental_fetch_to_device=False))\\n\\n validation_dataset = None\\n if 'eval' in mode:\\n validation_dataset = strategy.distribute_datasets_from_function(\\n get_dataset_fn(params.task.validation_data),\\n options=tf.distribute.InputOptions(experimental_fetch_to_device=False))\\n\\n if params.trainer.use_orbit:\\n with strategy.scope():\\n checkpoint_exporter = train_utils.maybe_create_best_ckpt_exporter(\\n params, model_dir)\\n trainer = RankingTrainer(\\n config=params,\\n task=task,\\n model=model,\\n optimizer=model.optimizer,\\n train='train' in mode,\\n evaluate='eval' in mode,\\n train_dataset=train_dataset,\\n validation_dataset=validation_dataset,\\n checkpoint_exporter=checkpoint_exporter)\\n\\n train_lib.run_experiment(\\n distribution_strategy=strategy,\\n task=task,\\n mode=mode,\\n params=params,\\n model_dir=model_dir,\\n trainer=trainer)\\n\\n else: # Compile/fit\\n checkpoint = tf.train.Checkpoint(model=model, optimizer=model.optimizer)\\n\\n latest_checkpoint = tf.train.latest_checkpoint(model_dir)\\n if latest_checkpoint:\\n checkpoint.restore(latest_checkpoint)\\n logging.info('Loaded checkpoint %s', latest_checkpoint)\\n\\n checkpoint_manager = tf.train.CheckpointManager(\\n checkpoint,\\n directory=model_dir,\\n max_to_keep=params.trainer.max_to_keep,\\n step_counter=model.optimizer.iterations,\\n checkpoint_interval=params.trainer.checkpoint_interval)\\n checkpoint_callback = keras_utils.SimpleCheckpoint(checkpoint_manager)\\n\\n time_callback = keras_utils.TimeHistory(\\n params.task.train_data.global_batch_size,\\n params.trainer.time_history.log_steps,\\n logdir=model_dir if enable_tensorboard else None)\\n callbacks = [checkpoint_callback, time_callback]\\n\\n if enable_tensorboard:\\n tensorboard_callback = tf.keras.callbacks.TensorBoard(\\n log_dir=model_dir,\\n update_freq=min(1000, params.trainer.validation_interval),\\n profile_batch=FLAGS.profile_steps)\\n callbacks.append(tensorboard_callback)\\n\\n num_epochs = (params.trainer.train_steps //\\n params.trainer.validation_interval)\\n current_step = model.optimizer.iterations.numpy()\\n initial_epoch = current_step // params.trainer.validation_interval\\n\\n eval_steps = params.trainer.validation_steps if 'eval' in mode else None\\n\\n if mode in ['train', 'train_and_eval']:\\n logging.info('Training started')\\n history = model.fit(\\n train_dataset,\\n initial_epoch=initial_epoch,\\n epochs=num_epochs,\\n steps_per_epoch=params.trainer.validation_interval,\\n validation_data=validation_dataset,\\n validation_steps=eval_steps,\\n callbacks=callbacks,\\n )\\n model.summary()\\n logging.info('Train history: %s', history.history)\\n elif mode == 'eval':\\n logging.info('Evaluation started')\\n validation_output = model.evaluate(validation_dataset, steps=eval_steps)\\n logging.info('Evaluation output: %s', validation_output)\\n else:\\n raise NotImplementedError('The mode is not implemented: %s' % mode)\",\n \"def train(self, resume_from_checkpoint: Optional[Union[str, bool]] = None,\\n trial: Union[\\\"optuna.Trial\\\", Dict[str, Any]] = None, ignore_keys_for_eval: Optional[List[str]] = None, **kwargs):\\n\\n # memory metrics - must set up as early as possible\\n self._memory_tracker.start()\\n\\n args = self.args\\n\\n self.is_in_train = True\\n\\n # do_train is not a reliable argument, as it might not be set and .train() still called, so\\n # the following is a workaround:\\n if args.fp16_full_eval and not args.do_train:\\n self.model = self.model.to(args.device)\\n\\n if \\\"model_path\\\" in kwargs:\\n resume_from_checkpoint = kwargs.pop(\\\"model_path\\\")\\n if len(kwargs) > 0:\\n raise TypeError(f\\\"train() received got unexpected keyword arguments: {', '.join(list(kwargs.keys()))}.\\\")\\n\\n # This might change the seed so needs to run first.\\n self._hp_search_setup(trial)\\n\\n # Model re-init\\n model_reloaded = False\\n if self.model_init is not None:\\n # Seed must be set before instantiating the model when using model_init.\\n set_seed(args.seed)\\n self.model = self.call_model_init(trial)\\n model_reloaded = True\\n\\n # Reinitializes optimizer and scheduler\\n self.optimizer, self.lr_scheduler = None, None\\n\\n # Load potential model checkpoint\\n if isinstance(resume_from_checkpoint, bool) and resume_from_checkpoint:\\n resume_from_checkpoint = get_last_checkpoint(args.output_dir)\\n if resume_from_checkpoint is None:\\n raise ValueError(f\\\"No valid checkpoint found in output directory ({args.output_dir})\\\")\\n\\n # If model was re-initialized, put it on the right device and update self.model_wrapped\\n if model_reloaded:\\n if self.place_model_on_device:\\n self.model = self.model.to(args.device)\\n self.model_wrapped = self.model\\n\\n # Keeping track whether we can len() on the dataset or not\\n train_dataset_is_sized = isinstance(self.train_dataset, collections.abc.Sized)\\n\\n # Data loader and number of training steps\\n train_dataloader = self.get_train_dataloader()\\n\\n # Setting up training control variables:\\n # number of training epochs: num_train_epochs\\n # number of training steps per epoch: num_update_steps_per_epoch\\n # total number of training steps to execute: max_steps\\n if train_dataset_is_sized:\\n num_update_steps_per_epoch = len(train_dataloader) // args.gradient_accumulation_steps\\n num_update_steps_per_epoch = max(num_update_steps_per_epoch, 1)\\n if args.max_steps > 0:\\n max_steps = args.max_steps\\n num_train_epochs = args.max_steps // num_update_steps_per_epoch + int(\\n args.max_steps % num_update_steps_per_epoch > 0\\n )\\n else:\\n max_steps = math.ceil(args.num_train_epochs * num_update_steps_per_epoch)\\n num_train_epochs = math.ceil(args.num_train_epochs)\\n else:\\n # see __init__. max_steps is set when the dataset has no __len__\\n max_steps = args.max_steps\\n num_train_epochs = int(args.num_train_epochs)\\n num_update_steps_per_epoch = max_steps\\n\\n self.create_optimizer_and_scheduler(num_training_steps=max_steps)\\n\\n self.state = TrainerState()\\n self.state.is_hyper_param_search = trial is not None\\n\\n model = self._wrap_model(self.model_wrapped)\\n\\n # for the rest of this function `model` is the outside model, whether it was wrapped or not\\n if model is not self.model:\\n self.model_wrapped = model\\n\\n # Check if saved optimizer or scheduler states exist\\n self._load_optimizer_and_scheduler(resume_from_checkpoint)\\n\\n # Train!\\n world_size = 1 # number of processes in parallel\\n\\n total_train_batch_size = args.train_batch_size * args.gradient_accumulation_steps * world_size\\n num_examples = (self.num_examples(train_dataloader) if train_dataset_is_sized else total_train_batch_size * args.max_steps)\\n\\n logger.info(\\\"***** Running training *****\\\")\\n logger.info(f\\\" Num examples = {num_examples}\\\")\\n logger.info(f\\\" Num Epochs = {num_train_epochs}\\\")\\n logger.info(f\\\" Instantaneous batch size per device = {args.per_device_train_batch_size}\\\")\\n logger.info(f\\\" Total train batch size (w. parallel, distributed & accumulation) = {total_train_batch_size}\\\")\\n logger.info(f\\\" Gradient Accumulation steps = {args.gradient_accumulation_steps}\\\")\\n logger.info(f\\\" Total optimization steps = {max_steps}\\\")\\n\\n self.state.epoch = 0\\n start_time = time.time()\\n epochs_trained = 0\\n steps_trained_in_current_epoch = 0\\n steps_trained_progress_bar = None\\n\\n # Check if continuing training from a checkpoint\\n if resume_from_checkpoint is not None and os.path.isfile(os.path.join(resume_from_checkpoint, \\\"trainer_state.json\\\")):\\n self.state = TrainerState.load_from_json(os.path.join(resume_from_checkpoint, \\\"trainer_state.json\\\"))\\n epochs_trained = self.state.global_step // num_update_steps_per_epoch\\n if not args.ignore_data_skip:\\n steps_trained_in_current_epoch = self.state.global_step % (num_update_steps_per_epoch)\\n steps_trained_in_current_epoch *= args.gradient_accumulation_steps\\n else:\\n steps_trained_in_current_epoch = 0\\n\\n logger.info(\\\" Continuing training from checkpoint, will skip to saved global_step\\\")\\n logger.info(f\\\" Continuing training from epoch {epochs_trained}\\\")\\n logger.info(f\\\" Continuing training from global step {self.state.global_step}\\\")\\n if not args.ignore_data_skip:\\n logger.info(\\n f\\\" Will skip the first {epochs_trained} epochs then the first {steps_trained_in_current_epoch} \\\"\\n \\\"batches in the first epoch. If this takes a lot of time, you can add the `--ignore_data_skip` \\\"\\n \\\"flag to your launch command, but you will resume the training on data already seen by your model.\\\"\\n )\\n if self.is_local_process_zero() and not args.disable_tqdm:\\n steps_trained_progress_bar = tqdm(total=steps_trained_in_current_epoch)\\n steps_trained_progress_bar.set_description(\\\"Skipping the first batches\\\")\\n\\n # Update the references\\n self.callback_handler.model = self.model\\n self.callback_handler.optimizer = self.optimizer\\n self.callback_handler.lr_scheduler = self.lr_scheduler\\n self.callback_handler.train_dataloader = train_dataloader\\n self.state.trial_name = self.hp_name(trial) if self.hp_name is not None else None\\n self.state.trial_params = hp_params(trial) if trial is not None else None\\n # This should be the same if the state has been saved but in case the training arguments changed, it's safer\\n # to set this after the load.\\n self.state.max_steps = max_steps\\n self.state.num_train_epochs = num_train_epochs\\n self.state.is_local_process_zero = self.is_local_process_zero()\\n self.state.is_world_process_zero = self.is_world_process_zero()\\n\\n # tr_loss is a tensor to avoid synchronization of TPUs through .item()\\n tr_loss = torch.tensor(0.0).to(args.device)\\n # _total_loss_scalar is updated everytime .item() has to be called on tr_loss and stores the sum of all losses\\n self._total_loss_scalar = 0.0\\n self._globalstep_last_logged = self.state.global_step\\n model.zero_grad()\\n\\n self.control = self.callback_handler.on_train_begin(args, self.state, self.control)\\n\\n # Skip the first epochs_trained epochs to get the random state of the dataloader at the right point.\\n if not args.ignore_data_skip:\\n for epoch in range(epochs_trained):\\n # We just need to begin an iteration to create the randomization of the sampler.\\n for _ in train_dataloader:\\n break\\n\\n for epoch in range(epochs_trained, num_train_epochs):\\n epoch_iterator = train_dataloader\\n\\n # Reset the past mems state at the beginning of each epoch if necessary.\\n if args.past_index >= 0:\\n self._past = None\\n\\n steps_in_epoch = (len(epoch_iterator) if train_dataset_is_sized else args.max_steps * args.gradient_accumulation_steps)\\n self.control = self.callback_handler.on_epoch_begin(args, self.state, self.control)\\n\\n for step, inputs in enumerate(epoch_iterator):\\n # Skip past any already trained steps if resuming training\\n if steps_trained_in_current_epoch > 0:\\n steps_trained_in_current_epoch -= 1\\n if steps_trained_progress_bar is not None:\\n steps_trained_progress_bar.update(1)\\n if steps_trained_in_current_epoch == 0:\\n self._load_rng_state(resume_from_checkpoint)\\n continue\\n\\n elif steps_trained_progress_bar is not None:\\n steps_trained_progress_bar.close()\\n steps_trained_progress_bar = None\\n\\n if step % args.gradient_accumulation_steps == 0:\\n self.control = self.callback_handler.on_step_begin(args, self.state, self.control)\\n\\n tr_loss += self.custom_training_step(model, inputs)\\n\\n self.current_flos += float(self.floating_point_ops(inputs))\\n\\n # Optimizer step for deepspeed must be called on every step regardless of the value of gradient_accumulation_steps\\n if (step + 1) % args.gradient_accumulation_steps == 0 or (\\n # last step in epoch but step is always smaller than gradient_accumulation_steps\\n steps_in_epoch <= args.gradient_accumulation_steps\\n and (step + 1) == steps_in_epoch\\n ):\\n # Gradient clipping\\n if args.max_grad_norm is not None and args.max_grad_norm > 0:\\n torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)\\n\\n # Optimizer step\\n optimizer_was_run = True\\n self.optimizer.step()\\n\\n if optimizer_was_run:\\n self.lr_scheduler.step()\\n\\n model.zero_grad()\\n\\n self.state.global_step += 1\\n self.state.epoch = epoch + (step + 1) / steps_in_epoch\\n self.control = self.callback_handler.on_step_end(args, self.state, self.control)\\n\\n self._maybe_log_save_evaluate(tr_loss, model, trial, epoch, ignore_keys_for_eval)\\n\\n if self.control.should_epoch_stop or self.control.should_training_stop:\\n break\\n\\n self.control = self.callback_handler.on_epoch_end(args, self.state, self.control)\\n self._maybe_log_save_evaluate(tr_loss, model, trial, epoch, ignore_keys_for_eval)\\n\\n if self.control.should_training_stop:\\n break\\n\\n if args.past_index and hasattr(self, \\\"_past\\\"):\\n # Clean the state at the end of training\\n delattr(self, \\\"_past\\\")\\n\\n logger.info(\\\"\\\\n\\\\nTraining completed. Do not forget to share your model on huggingface.co/models =)\\\\n\\\\n\\\")\\n if args.load_best_model_at_end and self.state.best_model_checkpoint is not None:\\n logger.info(f\\\"Loading best model from {self.state.best_model_checkpoint} (score: {self.state.best_metric}).\\\")\\n\\n # We load the model state dict on the CPU to avoid an OOM error.\\n state_dict = torch.load(os.path.join(self.state.best_model_checkpoint, WEIGHTS_NAME), map_location=\\\"cpu\\\")\\n # If the model is on the GPU, it still works!\\n self.model.load_state_dict(state_dict)\\n\\n metrics = speed_metrics(\\\"train\\\", start_time, self.state.max_steps)\\n self.store_flos()\\n metrics[\\\"total_flos\\\"] = self.state.total_flos\\n self.log(metrics)\\n\\n self.control = self.callback_handler.on_train_end(args, self.state, self.control)\\n # add remaining tr_loss\\n self._total_loss_scalar += tr_loss.item()\\n\\n self.is_in_train = False\\n\\n self._memory_tracker.stop_and_update_metrics(metrics)\\n\\n return TrainOutput(self.state.global_step, self._total_loss_scalar / self.state.global_step, metrics)\",\n \"def load_model(self, ckpt_name=\\\"best_model.pth\\\"):\\n path = \\\"/\\\".join(ckpt_name.split(\\\"/\\\")[:-1])\\n chkpt = torch.load(ckpt_name)\\n self.start_epoch = chkpt['epoch']\\n self.best_metric = chkpt['best_metric']\\n\\n # fix the DataParallel caused problem with keys names\\n if self.multi_gpu_flag:\\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=False)\\n self.net.load_state_dict(new_state_dict)\\n else:\\n try:\\n self.net.load_state_dict(chkpt['state_dict'])\\n except:\\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=True)\\n self.net.load_state_dict(new_state_dict)\\n\\n if self.load_optimizer_state:\\n self.optimizer.load_state_dict(chkpt['optimizer'])\\n logging.info(\\\"******** State loaded ********\\\")\\n\\n training_meta = pickle.load(open(f\\\"{path}/training_meta.pickle.dat\\\", \\\"rb\\\"))\\n for k, v in training_meta.items():\\n if k in self.__class__.__params:\\n setattr(self, k, v)\\n logging.info(\\\"******** Training params loaded ********\\\")\",\n \"def main_modeling_pipeline():\\n\\n\\n data_df = pd.read_csv('gs://aiplatformfilipegracio2020/head_train_data.csv')\\n data_df = data_df[[LABEL, 'price', 'days_on_site']]\\n\\n class_weights = calculate_class_weights(data_df[LABEL])\\n print('class weights', class_weights)\\n logging.info('Data loaded and processed')\\n train_ds, val_ds, test_ds = make_tf_datasets(data_df, LABEL)\\n logging.info('Tensorflow datasets created')\\n\\n with strategy.scope():\\n logging.info('Inside strategy')\\n simple_feature_layer = make_simple_feature_layer(data_df)\\n logging.info('Going to make model')\\n simple_model = make_simple_model(simple_feature_layer)\\n\\n logging.info('Going fit model')\\n simple_model_results, simple_model = model_fit_and_evaluate(model=simple_model,\\n train_ds=train_ds,\\n val_ds=val_ds,\\n test_ds=test_ds,\\n class_weights=class_weights,\\n epochs=TRAINING_EPOCHS,\\n job_name='simple_model')\\n\\n simple_model.save('gs://aiplatformfilipegracio2020/')\",\n \"def launch(self):\\n self.register_env_creator()\\n\\n # All worker nodes will block at this step during training\\n ray_cluster_config = self.ray_init_config()\\n if not self.is_master_node:\\n return\\n\\n # Start the driver on master node\\n ray.init(**ray_cluster_config)\\n experiment_config = self.get_experiment_config()\\n experiment_config = self.customize_experiment_config(experiment_config)\\n print(\\\"Running experiment with config %s\\\" % json.dumps(experiment_config, indent=2))\\n run_experiments(experiment_config)\\n\\n all_wokers_host_names = self.get_all_host_names()[1:]\\n # If distributed job, send TERMINATION_SIGNAL to all workers.\\n if len(all_wokers_host_names) > 0:\\n self.sage_cluster_communicator.create_s3_signal(TERMINATION_SIGNAL)\",\n \"def main():\\n setup_keras()\\n\\n args = parse()\\n\\n train_settings = common.load_settings(args.settings_path, default_conf_name='train.yml')\\n train_settings['store'] = args.store\\n\\n feature_settings = common.load_settings(args.settings_path, default_conf_name='feature.yml')\\n model_settings = common.load_settings(args.settings_path, default_conf_name=train_settings['model_conf'])\\n\\n train_df, val_df = load_training_data(dict(train_settings, **feature_settings))\\n assert train_df.shape[0] > val_df.shape[0] * 4.5, f'training data {train_df.shape[0]} should be much larger than validation {val_df.shape[0]}'\\n\\n sample_featurizer = AudioFeature(feature_settings)\\n\\n if args.load_name:\\n model_name = args.load_name\\n print('Loading existing model', model_name)\\n m = keras.models.load_model(model_name)\\n else:\\n t = datetime.datetime.now().strftime('%Y%m%d-%H%M')\\n model_name = f\\\"model-{model_settings['model']}_hop{feature_settings['hop_length']}_{t}\\\"\\n m = models.build(dict(model_settings, **feature_settings))\\n m.summary()\\n\\n output_dir = os.path.join(args.model_store, model_name)\\n\\n print(f\\\"Training model: '{model_name}'\\\", json.dumps(train_settings, indent=1))\\n\\n combined_settings = dict(train_settings, **model_settings, **feature_settings)\\n\\n h = train_model(output_dir, train_df, val_df,\\n model=m,\\n sample_featurizer=sample_featurizer,\\n settings=combined_settings)\",\n \"def setup_training(model, train_loader, valid_loader, hps):\\r\\n\\r\\n train_dir = os.path.join(hps.save_root, \\\"train\\\")\\r\\n if not os.path.exists(train_dir): os.makedirs(train_dir)\\r\\n\\r\\n if hps.restore_model != 'None':\\r\\n logger.info(\\\"[INFO] Restoring %s for training...\\\", hps.restore_model)\\r\\n bestmodel_file = os.path.join(train_dir, hps.restore_model)\\r\\n loader = ModelLoader()\\r\\n loader.load_pytorch(model, bestmodel_file)\\r\\n else:\\r\\n logger.info(\\\"[INFO] Create new model for training...\\\")\\r\\n\\r\\n run_training(model, train_loader, valid_loader, hps) # this is an infinite loop until interrupted\\r\",\n \"def train_main(cls):\\n launcher = cls()\\n launcher.launch()\",\n \"def set_train(self):\\n for m in self.models.values():\\n m.train()\",\n \"def model_pipeline_run(index, model, params, X_train, y_train, X_test, y_test, model_name, pre_process_time, type):\\n n_jobs = -1\\n n_iter = 100\\n if model is None:\\n return\\n try:\\n row = {\\\"dataset_index\\\": index}\\n if type == \\\"classification\\\":\\n steps = [(\\\"classifier\\\", model)]\\n else:\\n steps = [(\\\"regressor\\\", model)]\\n pipeline = MLPipeline(steps=steps)\\n if type == \\\"classification\\\":\\n if model_name == \\\"rf\\\":\\n params[\\\"classifier__max_features\\\"] = [min([x, X_train.shape[1]]) for x in\\n params[\\\"classifier__max_features\\\"]]\\n elif \\\"dl\\\" in model_name:\\n n_jobs = None\\n params[\\\"classifier__shape\\\"] = [X_train.shape[1]]\\n if isinstance(y_test[0], (str)):\\n try:\\n y_train = np.asarray(list(map(lambda x: int(re.search(\\\"[0-9]+\\\", x).group()), y_train)))\\n y_test = np.asarray(list(map(lambda x: int(re.search(\\\"[0-9]+\\\", x).group()), y_test)))\\n except Exception as e:\\n le = LabelEncoder()\\n y_train = le.fit_transform(y_train)\\n y_test = le.transform(y_test)\\n grid = RandomizedSearchCV(estimator=pipeline, param_distributions=params, cv=KFold(3), refit=True,\\n verbose=0, n_jobs=n_jobs, n_iter=n_iter,\\n scoring=\\\"f1\\\" if len(set(y_train)) == 2 else \\\"f1_weighted\\\")\\n else:\\n if model_name == \\\"rf\\\":\\n params[\\\"regressor__max_features\\\"] = [min([x, X_train.shape[1]]) for x in\\n params[\\\"regressor__max_features\\\"]]\\n elif \\\"dl\\\" in model_name:\\n n_jobs = None\\n params[\\\"regressor__shape\\\"] = [X_train.shape[1]]\\n grid = RandomizedSearchCV(estimator=pipeline, param_distributions=params, cv=KFold(3), refit=True,\\n verbose=0, n_jobs=n_jobs, n_iter=n_iter, error_score=np.nan)\\n model_time = time.time()\\n columns = X_train.columns\\n if \\\"dl-rnn\\\" in model_name:\\n X_train = np.reshape(X_train.astype(\\\"float32\\\").values, (X_train.shape[0], 1, X_train.shape[1]))\\n X_test = np.reshape(X_test.astype(\\\"float32\\\").values, (X_test.shape[0], 1, X_test.shape[1]))\\n else:\\n X_train = X_train.astype(\\\"float32\\\").values\\n X_test = X_test.astype(\\\"float32\\\").values\\n grid = grid.fit(X_train.astype(\\\"float32\\\"), y_train)\\n row[\\\"time\\\"] = (time.time() - model_time) / 60\\n row[\\\"pre_process_time\\\"] = pre_process_time\\n return scoring(grid, X_train, X_test, y_train, y_test, columns, row=row, model_name=model_name, type=type)\\n except Exception as e:\\n print(e)\",\n \"def set_load_model_parameters(self):\\n\\n self.controller.set_new_model_test_input_path(self.test_input.get())\\n self.controller.set_new_model_results_input_path(self.results_input.get())\\n self.controller.set_new_model_running(False)\",\n \"def train(log_dir):\\n\\n # Create train and test environments\\n print(\\n colorize(\\n f\\\"INFO: You are training in the {ENV_NAME} environment.\\\",\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n env = get_env_from_name(ENV_NAME, ENV_SEED)\\n test_env = get_env_from_name(ENV_NAME, ENV_SEED)\\n\\n # Set initial learning rates\\n lr_a, lr_l, lr_c = (\\n ALG_PARAMS[\\\"lr_a\\\"],\\n ALG_PARAMS[\\\"lr_l\\\"],\\n ALG_PARAMS[\\\"lr_c\\\"],\\n )\\n lr_a_now = ALG_PARAMS[\\\"lr_a\\\"] # learning rate for actor, lambda and alpha\\n lr_l_now = ALG_PARAMS[\\\"lr_l\\\"] # learning rate for Lyapunov critic\\n lr_c_now = ALG_PARAMS[\\\"lr_c\\\"] # learning rate for q critic\\n\\n # Get observation and action space dimension and limits from the environment\\n s_dim = env.observation_space.shape[0]\\n a_dim = env.action_space.shape[0]\\n a_lowerbound = env.action_space.low\\n a_upperbound = env.action_space.high\\n\\n # Create the Agent\\n policy = LAC(a_dim, s_dim, act_limits={\\\"low\\\": a_lowerbound, \\\"high\\\": a_upperbound})\\n\\n # Load model if retraining is selected\\n if TRAIN_PARAMS[\\\"continue_training\\\"]:\\n\\n # Create retrain model path\\n retrain_model_folder = TRAIN_PARAMS[\\\"continue_model_folder\\\"]\\n retrain_model_path = osp.abspath(\\n osp.join(log_dir, \\\"../..\\\", TRAIN_PARAMS[\\\"continue_model_folder\\\"])\\n )\\n\\n # Check if retrain model exists if not throw error\\n if not osp.exists(retrain_model_path):\\n print(\\n colorize(\\n (\\n \\\"ERROR: Shutting down training since the model you specified \\\"\\n f\\\"in the `continue_model_folder` `{retrain_model_folder}` \\\"\\n f\\\"argument was not found for the `{ENV_NAME}` environment.\\\"\\n ),\\n \\\"red\\\",\\n bold=True,\\n )\\n )\\n sys.exit(0)\\n\\n # Load old model\\n print(\\n colorize(\\n f\\\"INFO: Restoring model `{retrain_model_path}`.\\\", \\\"cyan\\\", bold=True\\n )\\n )\\n result = policy.restore(\\n osp.abspath(osp.join(retrain_model_path, \\\"policy\\\")),\\n restore_lagrance_multipliers=(not ALG_PARAMS[\\\"reset_lagrance_multipliers\\\"]),\\n )\\n if not result:\\n print(\\n colorize(\\n \\\"ERROR: Shuting down training as something went wrong while \\\"\\n \\\"loading \\\"\\n f\\\"model `{retrain_model_folder}`.\\\",\\n \\\"red\\\",\\n bold=True,\\n )\\n )\\n sys.exit(0)\\n\\n # Create new storage folder\\n log_dir_split = log_dir.split(\\\"/\\\")\\n log_dir_split[-2] = (\\n \\\"_\\\".join(TRAIN_PARAMS[\\\"continue_model_folder\\\"].split(\\\"/\\\")) + \\\"_finetune\\\"\\n )\\n log_dir = \\\"/\\\".join(log_dir_split)\\n else:\\n print(colorize(f\\\"INFO: Train new model `{log_dir}`\\\", \\\"cyan\\\", bold=True))\\n\\n # Print logging folder path\\n print(colorize(f\\\"INFO: Logging results to `{log_dir}`.\\\", \\\"cyan\\\", bold=True))\\n\\n # Create replay memory buffer\\n pool = Pool(\\n s_dim=s_dim,\\n a_dim=a_dim,\\n store_last_n_paths=TRAIN_PARAMS[\\\"num_of_training_paths\\\"],\\n memory_capacity=ALG_PARAMS[\\\"memory_capacity\\\"],\\n min_memory_size=ALG_PARAMS[\\\"min_memory_size\\\"],\\n )\\n\\n # Setup logger and log hyperparameters\\n logger.configure(dir=log_dir, format_strs=[\\\"csv\\\"])\\n logger.logkv(\\\"tau\\\", ALG_PARAMS[\\\"tau\\\"])\\n logger.logkv(\\\"alpha3\\\", ALG_PARAMS[\\\"alpha3\\\"])\\n logger.logkv(\\\"batch_size\\\", ALG_PARAMS[\\\"batch_size\\\"])\\n logger.logkv(\\\"target_entropy\\\", policy.target_entropy)\\n\\n ####################################################\\n # Training loop ####################################\\n ####################################################\\n\\n # Setup training loop parameters\\n t1 = time.time()\\n global_step = 0\\n global_episodes = 0\\n last_training_paths = deque(maxlen=TRAIN_PARAMS[\\\"num_of_training_paths\\\"])\\n training_started = False\\n\\n # Train the agent in the environment until max_episodes has been reached\\n print(colorize(\\\"INFO: Training...\\\\n\\\", \\\"cyan\\\", bold=True))\\n while 1: # Keep running episodes until global step has been reached\\n\\n # Create variable to store information about the current path\\n if policy.use_lyapunov:\\n current_path = {\\n \\\"rewards\\\": [],\\n \\\"lyapunov_error\\\": [],\\n \\\"alpha\\\": [],\\n \\\"lambda\\\": [],\\n \\\"entropy\\\": [],\\n \\\"a_loss\\\": [],\\n \\\"alpha_loss\\\": [],\\n \\\"lambda_loss\\\": [],\\n }\\n else:\\n current_path = {\\n \\\"rewards\\\": [],\\n \\\"critic_error\\\": [],\\n \\\"alpha\\\": [],\\n \\\"entropy\\\": [],\\n \\\"a_loss\\\": [],\\n \\\"alpha_loss\\\": [],\\n }\\n\\n # Reset environment\\n s = env.reset()\\n\\n # Training Episode loop\\n for jj in range(ENVS_PARAMS[ENV_NAME][\\\"max_ep_steps\\\"]):\\n\\n # Break out of loop if global steps have been reached\\n if global_step >= TRAIN_PARAMS[\\\"max_global_steps\\\"]:\\n\\n # Print step count, save model and stop the program\\n print(\\n colorize(\\n f\\\"\\\\nINFO: Training stopped after {global_step} steps.\\\",\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n print(\\n colorize(\\n \\\"INFO: Running time: {}\\\".format(time.time() - t1),\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n print(colorize(\\\"INFO: Saving Model\\\", \\\"cyan\\\", bold=True))\\n policy.save_result(log_dir)\\n return\\n\\n # Save intermediate checkpoints if requested\\n if TRAIN_PARAMS[\\\"save_checkpoints\\\"]:\\n if (\\n global_step % TRAIN_PARAMS[\\\"checkpoint_save_freq\\\"] == 0\\n and global_step != 0\\n ):\\n\\n # Create intermediate result checkpoint folder\\n checkpoint_save_path = osp.abspath(\\n osp.join(log_dir, \\\"checkpoints\\\", \\\"step_\\\" + str(jj))\\n )\\n os.makedirs(checkpoint_save_path, exist_ok=True)\\n\\n # Save intermediate checkpoint\\n policy.save_result(checkpoint_save_path)\\n\\n # Render environment if requested\\n if ENVS_PARAMS[ENV_NAME][\\\"eval_render\\\"]:\\n env.render()\\n\\n # Retrieve (scaled) action based on the current policy\\n # NOTE (rickstaa): The scaling operation is already performed inside the\\n # policy based on the `act_limits` you supplied.\\n a = policy.choose_action(s)\\n\\n # Perform action in env\\n s_, r, done, _ = env.step(a)\\n\\n # Increment global step count\\n if training_started:\\n global_step += 1\\n\\n # Stop episode if max_steps has been reached\\n if jj == ENVS_PARAMS[ENV_NAME][\\\"max_ep_steps\\\"] - 1:\\n done = True\\n terminal = 1.0 if done else 0.0\\n\\n # Store experience in replay buffer\\n pool.store(s, a, r, terminal, s_)\\n\\n # Optimize network weights and lagrance multipliers\\n if (\\n pool.memory_pointer > ALG_PARAMS[\\\"min_memory_size\\\"]\\n and global_step % ALG_PARAMS[\\\"steps_per_cycle\\\"] == 0\\n ):\\n training_started = True\\n\\n # Perform STG a set number of times (train per cycle)\\n for _ in range(ALG_PARAMS[\\\"train_per_cycle\\\"]):\\n batch = pool.sample(ALG_PARAMS[\\\"batch_size\\\"])\\n if policy.use_lyapunov:\\n (\\n labda,\\n alpha,\\n l_loss,\\n entropy,\\n a_loss,\\n alpha_loss,\\n labda_loss,\\n ) = policy.learn(lr_a_now, lr_l_now, lr_a, lr_c_now, batch)\\n else:\\n alpha, loss_q, entropy, a_loss, alpha_loss = policy.learn(\\n lr_a_now, lr_l_now, lr_a, lr_c_now, batch\\n )\\n\\n # Store current path results\\n if training_started:\\n if policy.use_lyapunov:\\n current_path[\\\"rewards\\\"].append(r)\\n current_path[\\\"lyapunov_error\\\"].append(l_loss)\\n current_path[\\\"alpha\\\"].append(alpha)\\n current_path[\\\"lambda\\\"].append(labda)\\n current_path[\\\"entropy\\\"].append(entropy)\\n current_path[\\\"a_loss\\\"].append(a_loss)\\n current_path[\\\"alpha_loss\\\"].append(alpha_loss)\\n current_path[\\\"lambda_loss\\\"].append(labda_loss)\\n else:\\n current_path[\\\"rewards\\\"].append(r)\\n current_path[\\\"critic_error\\\"].append(loss_q.numpy())\\n current_path[\\\"alpha\\\"].append(alpha.numpy())\\n current_path[\\\"entropy\\\"].append(entropy.numpy())\\n current_path[\\\"a_loss\\\"].append(\\n a_loss.numpy()\\n ) # Improve: Check if this is the fastest way\\n current_path[\\\"alpha_loss\\\"].append(alpha_loss)\\n\\n # Evalute the current policy performance and log the results\\n if (\\n training_started\\n and global_step % TRAIN_PARAMS[\\\"evaluation_frequency\\\"] == 0\\n and global_step > 0\\n ):\\n logger.logkv(\\\"total_timesteps\\\", global_step)\\n training_diagnostics = evaluate_training_rollouts(last_training_paths)\\n if training_diagnostics is not None:\\n if TRAIN_PARAMS[\\\"num_of_evaluation_paths\\\"] > 0:\\n eval_diagnostics = training_evaluation(test_env, policy)\\n [\\n logger.logkv(key, eval_diagnostics[key])\\n for key in eval_diagnostics.keys()\\n ]\\n training_diagnostics.pop(\\\"return\\\")\\n [\\n logger.logkv(key, training_diagnostics[key])\\n for key in training_diagnostics.keys()\\n ]\\n logger.logkv(\\\"lr_a\\\", lr_a_now)\\n if policy.use_lyapunov:\\n logger.logkv(\\\"lr_l\\\", lr_l_now)\\n else:\\n logger.logkv(\\\"lr_c\\\", lr_c_now)\\n string_to_print = [\\\"time_step:\\\", str(global_step), \\\"|\\\"]\\n if TRAIN_PARAMS[\\\"num_of_evaluation_paths\\\"] > 0:\\n [\\n string_to_print.extend(\\n [key, \\\":\\\", str(eval_diagnostics[key]), \\\"|\\\"]\\n )\\n for key in eval_diagnostics.keys()\\n ]\\n [\\n string_to_print.extend(\\n [key, \\\":\\\", str(round(training_diagnostics[key], 2)), \\\"|\\\"]\\n )\\n for key in training_diagnostics.keys()\\n ]\\n prefix = (\\n colorize(\\\"LAC|\\\", \\\"green\\\")\\n if ALG_PARAMS[\\\"use_lyapunov\\\"]\\n else colorize(\\\"SAC|\\\", \\\"yellow\\\")\\n )\\n print(\\n colorize(prefix, \\\"yellow\\\", bold=True) + \\\"\\\".join(string_to_print)\\n )\\n logger.dumpkvs()\\n\\n # Update state\\n s = s_\\n\\n # Check if episode is done (continue to next episode)\\n if done:\\n\\n # Store paths\\n if training_started:\\n last_training_paths.appendleft(current_path)\\n\\n # Decay learning rates\\n frac = 1.0 - (global_step - 1.0) / TRAIN_PARAMS[\\\"max_global_steps\\\"]\\n lr_a_now = lr_a * frac # learning rate for actor, lambda, alpha\\n lr_l_now = lr_l * frac # learning rate for Lyapunov critic\\n lr_c_now = lr_c * frac # learning rate for q critic\\n break # Continue to next episode\\n\\n # Increase episode counter\\n global_episodes += 1\",\n \"def _set_train(self):\\n\\n if not self.model.__dict__['training']:\\n self.model.train()\",\n \"def train_distributed():\\n # Distributed stuff learnt from this repo: https://github.com/GoogleCloudPlatform/cloudml-dist-\\n # mnist-example/blob/master/trainer/task.py\\n\\n # For Distributed TensorFlow\\n env = json.loads(os.environ.get('TF_CONFIG', '{}'))\\n cluster_info = env.get('cluster')\\n cluster_spec = tf.train.ClusterSpec(cluster_info)\\n task_info = env.get('task')\\n job_name, task_index = task_info['type'], task_info['index']\\n\\n device_fn = tf.train.replica_device_setter(\\n cluster=cluster_spec,\\n worker_device='/job:%s/task:%d' % (job_name, task_index))\\n\\n print(\\\"Start job:%s, index:%d\\\" % (job_name, task_index))\\n\\n server = tf.train.Server(cluster_spec,\\n job_name=job_name, task_index=task_index)\\n\\n # Start a parameter server node\\n if job_name == 'ps':\\n server.join()\\n\\n # Start a master/worker node\\n if job_name == 'master' or job_name == 'worker':\\n is_chief = (job_name == 'master')\\n\\n with tf.Graph().as_default() as graph: # TODO necessary?\\n with tf.device(device_fn):\\n # Prepare the data\\n train_data, test_data, embeddings_file = prepare_data()\\n\\n # Create the model\\n print(\\\"(%s,%d) Creating %d layers of %d units.\\\" %\\n (job_name, task_index, FLAGS.num_layers, FLAGS.size))\\n model = create_model(False)\\n\\n # Create train_dir\\n if is_chief:\\n if not tf.gfile.Exists(FLAGS.train_dir):\\n tf.gfile.MkDir(FLAGS.train_dir)\\n\\n # TensorBoard summaries\\n (test_loss, test_perplexity, bucket_loss_placeholders,\\n bucket_perplexity_placeholders, summary, summary_writer) = create_summary_objects(graph)\\n\\n # Create supervisor\\n init_op = tf.global_variables_initializer()\\n\\n # Create Supervisor. Disabling checkpoints and summaries, because we do that manually\\n sv = tf.train.Supervisor(is_chief=is_chief, logdir=FLAGS.train_dir, init_op=init_op,\\n init_fn=lambda session: after_init(session, model, embeddings_file),\\n saver=model.saver, global_step=model.global_step,\\n save_model_secs=0, save_summaries_secs=0, summary_op=None,\\n summary_writer=None)\\n\\n with sv.managed_session(server.target) as sess:\\n train(sess, model, train_data, test_data, summary, summary_writer, test_loss,\\n test_perplexity, bucket_loss_placeholders, bucket_perplexity_placeholders,\\n is_chief, job_name, task_index, sv.should_stop)\\n sv.stop()\",\n \"def train_parallel(config):\\n _setup_parallel_env()\\n print(f\\\" | Starting training on {os.getenv('RANK_SIZE', None)} devices.\\\")\\n\\n pre_train_dataset = load_dataset(\\n data_files=config.pre_train_dataset,\\n batch_size=config.batch_size,\\n sink_mode=config.dataset_sink_mode,\\n rank_size=MultiDevice.get_group_size(),\\n rank_id=MultiDevice.get_rank()\\n ) if config.pre_train_dataset else None\\n fine_tune_dataset = load_dataset(\\n data_files=config.fine_tune_dataset,\\n batch_size=config.batch_size,\\n sink_mode=config.dataset_sink_mode,\\n rank_size=MultiDevice.get_group_size(),\\n rank_id=MultiDevice.get_rank()\\n ) if config.fine_tune_dataset else None\\n test_dataset = load_dataset(\\n data_files=config.test_dataset,\\n batch_size=config.batch_size,\\n sink_mode=config.dataset_sink_mode,\\n rank_size=MultiDevice.get_group_size(),\\n rank_id=MultiDevice.get_rank()\\n ) if config.test_dataset else None\\n\\n _build_training_pipeline(config=config,\\n pre_training_dataset=pre_train_dataset,\\n fine_tune_dataset=fine_tune_dataset,\\n test_dataset=test_dataset)\",\n \"def train(self, log_in_tensorboard=True):\\n if log_in_tensorboard or self.config.save_model:\\n os.makedirs(self.config.results_path, exist_ok=True)\\n\\n # Manage GPUs\\n if 0 < self.num_gpus:\\n num_gpus_per_worker = self.num_gpus / (\\n self.config.train_on_gpu\\n + self.config.num_workers * self.config.selfplay_on_gpu\\n + log_in_tensorboard * self.config.selfplay_on_gpu\\n + self.config.use_last_model_value * self.config.reanalyse_on_gpu\\n )\\n if 1 < num_gpus_per_worker:\\n num_gpus_per_worker = math.floor(num_gpus_per_worker)\\n else:\\n num_gpus_per_worker = 0\\n\\n # Initialize workers\\n self.training_worker = trainer.Trainer.options(\\n num_cpus=0, num_gpus=num_gpus_per_worker if self.config.train_on_gpu else 0,\\n ).remote(self.checkpoint, self.config)\\n\\n self.shared_storage_worker = shared_storage.SharedStorage.remote(\\n self.checkpoint, self.config,\\n )\\n self.shared_storage_worker.set_info.remote(\\\"terminate\\\", False)\\n\\n self.replay_buffer_worker = replay_buffer.ReplayBuffer.remote(\\n self.checkpoint, self.replay_buffer, self.config\\n )\\n\\n if self.config.use_last_model_value:\\n self.reanalyse_worker = replay_buffer.Reanalyse.options(\\n num_cpus=0,\\n num_gpus=num_gpus_per_worker if self.config.reanalyse_on_gpu else 0,\\n ).remote(self.checkpoint, self.config)\\n\\n self.self_play_workers = [\\n self_play.SelfPlay.options(\\n num_cpus=0,\\n num_gpus=num_gpus_per_worker if self.config.selfplay_on_gpu else 0,\\n ).remote(\\n self.checkpoint, self.Game, self.config, self.config.seed + seed,\\n )\\n for seed in range(self.config.num_workers)\\n ]\\n\\n # Launch workers\\n [\\n self_play_worker.continuous_self_play.remote(\\n self.shared_storage_worker, self.replay_buffer_worker\\n )\\n for self_play_worker in self.self_play_workers\\n ]\\n self.training_worker.continuous_update_weights.remote(\\n self.replay_buffer_worker, self.shared_storage_worker\\n )\\n if self.config.use_last_model_value:\\n self.reanalyse_worker.reanalyse.remote(\\n self.replay_buffer_worker, self.shared_storage_worker\\n )\\n\\n if log_in_tensorboard:\\n self.logging_loop(\\n num_gpus_per_worker if self.config.selfplay_on_gpu else 0,\\n )\",\n \"def train_and_eval(self):\\n self.__create_indexes()\\n model = None\\n model = None\\n if self.model == 'OMult':\\n model = OMult(self.kwargs)\\n elif self.model == 'ConvO':\\n model = ConvO(self.kwargs)\\n elif self.model == 'QMult':\\n model = QMult(self.kwargs)\\n elif self.model == 'ConvQ':\\n model = ConvQ(self.kwargs)\\n elif self.model == 'OMultBatch':\\n model = OMultBatch(self.kwargs)\\n elif self.model == 'ConvOBatch':\\n model = ConvOBatch(self.kwargs)\\n elif self.model == 'QMultBatch':\\n model = QMultBatch(self.kwargs)\\n elif self.model == 'ConvQBatch':\\n model = ConvQBatch(self.kwargs)\\n else:\\n print(self.model, ' is not valid name')\\n raise ValueError\\n\\n self.train(model)\\n self.eval(model)\",\n \"def go_train(sources, targets, model, dictloc, max_epochs):\\n\\n\\ttrain.trainer(targets, sources, model, \\n\\t\\tsaveto=\\\"data/trainer.npz\\\", \\n\\t\\tdictionary=dictloc, \\n\\t\\tmax_epochs=max_epochs, \\n\\t\\tsaveFreq=100, \\n\\t\\treload_=os.path.isfile(\\\"data/trainer.npz\\\")\\n\\t)\",\n \"def run_experiment(arguments):\\n\\n logging.info('Arguments: %s', arguments)\\n\\n # Get estimator\\n estimator = get_estimator(arguments)\\n # my_module.\\n\\n # Run training and evaluation\\n _train_and_evaluate(estimator, arguments.job_dir)\",\n \"def train(self, training_data):\\n pass\",\n \"def train(self):\\n train_dataloader = self.get_train_dataloader()\\n\\n if self.args.max_steps > 0:\\n t_total = self.args.max_steps\\n num_train_epochs = (\\n self.args.max_steps // (len(train_dataloader) // self.args.gradient_accumulation_steps) + 1\\n )\\n else:\\n t_total = int(len(train_dataloader) // self.args.gradient_accumulation_steps * self.args.num_train_epochs)\\n num_train_epochs = self.args.num_train_epochs\\n\\n lr_scheduler = orttrainer.optim.LinearWarmupLRScheduler(t_total, self.args.warmup_steps / float(t_total))\\n\\n loss_scaler = amp.DynamicLossScaler() if self.args.fp16 else None\\n device = self.args.device.type\\n\\n device = f\\\"{device}:{self.args.device.index}\\\" if self.args.device.index else f\\\"{device}:0\\\"\\n options = orttrainer.ORTTrainerOptions(\\n {\\n \\\"batch\\\": {\\\"gradient_accumulation_steps\\\": self.args.gradient_accumulation_steps},\\n \\\"device\\\": {\\\"id\\\": device},\\n \\\"mixed_precision\\\": {\\\"enabled\\\": self.args.fp16, \\\"loss_scaler\\\": loss_scaler},\\n \\\"debug\\\": {\\n \\\"deterministic_compute\\\": True,\\n },\\n \\\"utils\\\": {\\\"grad_norm_clip\\\": False},\\n \\\"distributed\\\": {\\n # we are running single node multi gpu test. thus world_rank = local_rank\\n # and world_size = self.args.n_gpu\\n \\\"world_rank\\\": max(0, self.args.local_rank),\\n \\\"world_size\\\": int(self.world_size),\\n \\\"local_rank\\\": max(0, self.args.local_rank),\\n \\\"allreduce_post_accumulation\\\": True,\\n },\\n \\\"lr_scheduler\\\": lr_scheduler,\\n }\\n )\\n\\n param_optimizer = list(self.model.named_parameters())\\n params = [\\n {\\n \\\"params\\\": [n for n, p in param_optimizer if \\\"bias\\\" in n or \\\"LayerNorm.weight\\\" in n],\\n \\\"weight_decay_mode\\\": 1,\\n },\\n {\\n \\\"params\\\": [n for n, p in param_optimizer if not (\\\"bias\\\" in n or \\\"LayerNorm.weight\\\" in n)],\\n \\\"weight_decay_mode\\\": 1,\\n },\\n ]\\n\\n optim_config = optim.AdamConfig(params=params, lr=2e-5, do_bias_correction=True)\\n self.model = orttrainer.ORTTrainer(self.model, self.model_desc, optim_config, options=options)\\n\\n # Train!\\n logger.info(\\\"***** Running training *****\\\")\\n logger.info(\\\" Num examples = %d\\\", len(train_dataloader.dataset))\\n logger.info(\\\" Num Epochs = %d\\\", num_train_epochs)\\n logger.info(\\\" Instantaneous batch size per GPU = %d\\\", self.args.per_gpu_train_batch_size)\\n logger.info(\\n \\\" Total train batch size (w. parallel, distributed & accumulation) = %d\\\",\\n self.args.train_batch_size\\n * self.args.gradient_accumulation_steps\\n * (torch.distributed.get_world_size() if self.args.local_rank != -1 else 1),\\n )\\n logger.info(\\\" Gradient Accumulation steps = %d\\\", self.args.gradient_accumulation_steps)\\n logger.info(\\\" Total optimization steps = %d\\\", t_total)\\n\\n global_step = 0\\n epochs_trained = 0\\n steps_trained_in_current_epoch = 0\\n\\n tr_loss = 0.0\\n logging_loss = 0.0\\n train_iterator = trange(\\n epochs_trained,\\n int(num_train_epochs),\\n desc=\\\"Epoch\\\",\\n disable=self.args.local_rank not in [-1, 0],\\n )\\n\\n for _epoch in train_iterator:\\n epoch_iterator = tqdm(train_dataloader, desc=\\\"Iteration\\\", disable=self.args.local_rank not in [-1, 0])\\n for step, inputs in enumerate(epoch_iterator):\\n # Skip past any already trained steps if resuming training\\n if steps_trained_in_current_epoch > 0:\\n steps_trained_in_current_epoch -= 1\\n continue\\n\\n tr_loss += self._training_step(self.model, inputs)\\n\\n if (step + 1) % self.args.gradient_accumulation_steps == 0 or (\\n len(epoch_iterator) <= self.args.gradient_accumulation_steps and (step + 1) == len(epoch_iterator)\\n ):\\n global_step += 1\\n\\n if self.args.local_rank in [-1, 0]:\\n if (self.args.logging_steps > 0 and global_step % self.args.logging_steps == 0) or (\\n global_step == 1 and self.args.logging_first_step\\n ):\\n logs = {}\\n if self.args.evaluate_during_training:\\n results = self.evaluate()\\n for key, value in results.items():\\n eval_key = f\\\"eval_{key}\\\"\\n logs[eval_key] = value\\n\\n loss_scalar = (tr_loss - logging_loss) / self.args.logging_steps\\n\\n logs[\\\"loss\\\"] = loss_scalar\\n logging_loss = tr_loss\\n\\n epoch_iterator.write(json.dumps({**logs, **{\\\"step\\\": global_step}}))\\n\\n if self.args.max_steps > 0 and global_step > self.args.max_steps:\\n epoch_iterator.close()\\n break\\n if self.args.max_steps > 0 and global_step > self.args.max_steps:\\n train_iterator.close()\\n break\\n\\n logger.info(\\\"\\\\n\\\\nTraining completed. \\\\n\\\\n\\\")\\n return TrainOutput(global_step, tr_loss / global_step)\",\n \"def Run(self, args):\\n job = jobs.BuildBatchPredictionJob(\\n job_name=args.job,\\n model_name=args.model,\\n version_name=args.version,\\n input_paths=args.input_paths,\\n data_format=args.data_format,\\n output_path=args.output_path,\\n region=args.region)\\n return jobs.Create(job)\",\n \"def train(self, uInputInfo):\\n if self.node_sharing:\\n ## train just one node,\\n self.pipes[0][0].send((\\\"train\\\", uInputInfo))\\n self.pipes[0][0].recv()\\n \\n else:\\n ## start each node's training\\n for i in range(len(self.nodes)):\\n for j in range(len(self.nodes[i])):\\n self.pipes[i][j].send((\\\"train\\\", uInputInfo))\\n\\n ## wait for the training to be finished\\n for i in range(len(self.nodes)):\\n for j in range(len(self.nodes[i])):\\n self.pipes[i][j].recv()\",\n \"def train(self, model, args):\\n if model == self.WORD_DET_RFC:\\n return self.train_rfc(args)\\n elif model == self.REGRESSION_PARAMS:\\n return self.train_bb_reg(args)\\n else:\\n raise Exception('No model %s exists to train' % model)\",\n \"def train_small_test_version(self, hyperparams_dict):\\n trainer = ModelTrainer(self.dataloaders, hyperparams_dict,\\n self.wv_wrapper, self.path)\\n model, losses, accuracies = trainer.train(epochs=3)\\n return model, losses, accuracies\",\n \"def set_train(self):\\n self.model.train()\",\n \"def train(\\n *,\\n workdir,\\n compute_phi,\\n compute_psi,\\n params,\\n optimal_subspace,\\n num_epochs,\\n learning_rate,\\n key,\\n method,\\n lissa_kappa,\\n optimizer,\\n covariance_batch_size,\\n main_batch_size,\\n weight_batch_size,\\n d,\\n num_tasks,\\n compute_feature_norm_on_oracle_states,\\n sample_states,\\n eval_states,\\n use_tabular_gradient = True,\\n):\\n # Create an explicit weight vector (needed for explicit method only).\\n if method == 'explicit':\\n key, weight_key = jax.random.split(key)\\n explicit_weight_matrix = jax.random.normal(\\n weight_key, (d, num_tasks), dtype=jnp.float32\\n )\\n params['explicit_weight_matrix'] = explicit_weight_matrix\\n\\n if optimizer == 'sgd':\\n optimizer = optax.sgd(learning_rate)\\n elif optimizer == 'adam':\\n optimizer = optax.adam(learning_rate)\\n else:\\n raise ValueError(f'Unknown optimizer {optimizer}.')\\n optimizer_state = optimizer.init(params)\\n\\n chkpt_manager = checkpoint.Checkpoint(base_directory=_WORKDIR.value)\\n initial_step, params, optimizer_state = chkpt_manager.restore_or_initialize(\\n (0, params, optimizer_state)\\n )\\n\\n writer = metric_writers.create_default_writer(\\n logdir=str(workdir),\\n )\\n\\n # Checkpointing and logging too much can use a lot of disk space.\\n # Therefore, we don't want to checkpoint more than 10 times an experiment,\\n # or keep more than 1k Phis per experiment.\\n checkpoint_period = max(num_epochs // 10, 100_000)\\n log_period = max(1_000, num_epochs // 1_000)\\n\\n def _checkpoint_callback(step, t, params, optimizer_state):\\n del t # Unused.\\n chkpt_manager.save((step, params, optimizer_state))\\n\\n hooks = [\\n periodic_actions.PeriodicCallback(\\n every_steps=checkpoint_period, callback_fn=_checkpoint_callback\\n )\\n ]\\n\\n fixed_train_kwargs = {\\n 'compute_phi': compute_phi,\\n 'compute_psi': compute_psi,\\n 'optimizer': optimizer,\\n 'method': method,\\n # In the tabular case, the eval_states are all the states.\\n 'oracle_states': eval_states,\\n 'lissa_kappa': lissa_kappa,\\n 'main_batch_size': main_batch_size,\\n 'covariance_batch_size': covariance_batch_size,\\n 'weight_batch_size': weight_batch_size,\\n 'd': d,\\n 'num_tasks': num_tasks,\\n 'compute_feature_norm_on_oracle_states': (\\n compute_feature_norm_on_oracle_states\\n ),\\n 'sample_states': sample_states,\\n 'use_tabular_gradient': use_tabular_gradient,\\n }\\n variable_kwargs = {\\n 'params': params,\\n 'optimizer_state': optimizer_state,\\n 'key': key,\\n }\\n\\n @jax.jit\\n def _eval_step(phi_params):\\n eval_phi = compute_phi(phi_params, eval_states)\\n eval_psi = compute_psi(eval_states) # pytype: disable=wrong-arg-count\\n\\n metrics = compute_metrics(eval_phi, optimal_subspace)\\n metrics |= {'frob_norm': utils.outer_objective_mc(eval_phi, eval_psi)}\\n return metrics\\n\\n # Perform num_epochs gradient steps.\\n with metric_writers.ensure_flushes(writer):\\n for step in etqdm.tqdm(\\n range(initial_step + 1, num_epochs + 1),\\n initial=initial_step,\\n total=num_epochs,\\n ):\\n variable_kwargs = _train_step(**fixed_train_kwargs, **variable_kwargs)\\n\\n if step % log_period == 0:\\n metrics = _eval_step(variable_kwargs['params']['phi_params'])\\n writer.write_scalars(step, metrics)\\n\\n for hook in hooks:\\n hook(\\n step,\\n params=variable_kwargs['params'],\\n optimizer_state=variable_kwargs['optimizer_state'],\\n )\\n\\n writer.flush()\",\n \"def hyperparameters(self):\\n hyperparameters = super(TensorFlow, self).hyperparameters()\\n\\n self.checkpoint_path = self.checkpoint_path or self._default_s3_path('checkpoints')\\n mpi_enabled = False\\n\\n if self._script_mode_enabled():\\n additional_hyperparameters = {}\\n\\n if 'parameter_server' in self.distributions:\\n ps_enabled = self.distributions['parameter_server'].get('enabled', False)\\n additional_hyperparameters[self.LAUNCH_PS_ENV_NAME] = ps_enabled\\n\\n if 'mpi' in self.distributions:\\n mpi_dict = self.distributions['mpi']\\n mpi_enabled = mpi_dict.get('enabled', False)\\n additional_hyperparameters[self.LAUNCH_MPI_ENV_NAME] = mpi_enabled\\n additional_hyperparameters[self.MPI_NUM_PROCESSES_PER_HOST] = mpi_dict.get('processes_per_host', 1)\\n additional_hyperparameters[self.MPI_CUSTOM_MPI_OPTIONS] = mpi_dict.get('custom_mpi_options', '')\\n\\n self.model_dir = self.model_dir or self._default_s3_path('model', mpi=mpi_enabled)\\n additional_hyperparameters['model_dir'] = self.model_dir\\n else:\\n additional_hyperparameters = {'checkpoint_path': self.checkpoint_path,\\n 'training_steps': self.training_steps,\\n 'evaluation_steps': self.evaluation_steps,\\n 'sagemaker_requirements': self.requirements_file}\\n\\n hyperparameters.update(Framework._json_encode_hyperparameters(additional_hyperparameters))\\n return hyperparameters\",\n \"def self_training(args):\\n\\n print('load pre-trained model from [%s]' % args.load_model, file=sys.stderr)\\n params = torch.load(args.load_model, map_location=lambda storage, loc: storage)\\n vocab = params['vocab']\\n transition_system = params['transition_system']\\n saved_args = params['args']\\n saved_state = params['state_dict']\\n\\n # transfer arguments\\n saved_args.cuda = args.cuda\\n saved_args.save_to = args.save_to\\n saved_args.train_file = args.train_file\\n saved_args.unlabeled_file = args.unlabeled_file\\n saved_args.dev_file = args.dev_file\\n saved_args.load_decode_results = args.load_decode_results\\n args = saved_args\\n\\n update_args(args)\\n\\n model = Parser(saved_args, vocab, transition_system)\\n model.load_state_dict(saved_state)\\n\\n if args.cuda: model = model.cuda()\\n model.train()\\n optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\\n\\n print('load unlabeled data [%s]' % args.unlabeled_file, file=sys.stderr)\\n unlabeled_data = Dataset.from_bin_file(args.unlabeled_file)\\n\\n print('load decoding results of unlabeled data [%s]' % args.load_decode_results, file=sys.stderr)\\n decode_results = pickle.load(open(args.load_decode_results))\\n\\n labeled_data = Dataset.from_bin_file(args.train_file)\\n dev_set = Dataset.from_bin_file(args.dev_file)\\n\\n print('Num. examples in unlabeled data: %d' % len(unlabeled_data), file=sys.stderr)\\n assert len(unlabeled_data) == len(decode_results)\\n self_train_examples = []\\n for example, hyps in zip(unlabeled_data, decode_results):\\n if hyps:\\n hyp = hyps[0]\\n sampled_example = Example(idx='self_train-%s' % example.idx,\\n src_sent=example.src_sent,\\n tgt_code=hyp.code,\\n tgt_actions=hyp.action_infos,\\n tgt_ast=hyp.tree)\\n self_train_examples.append(sampled_example)\\n print('Num. self training examples: %d, Num. labeled examples: %d' % (len(self_train_examples), len(labeled_data)),\\n file=sys.stderr)\\n\\n train_set = Dataset(examples=labeled_data.examples + self_train_examples)\\n\\n print('begin training, %d training examples, %d dev examples' % (len(train_set), len(dev_set)), file=sys.stderr)\\n print('vocab: %s' % repr(vocab), file=sys.stderr)\\n\\n epoch = train_iter = 0\\n report_loss = report_examples = 0.\\n history_dev_scores = []\\n num_trial = patience = 0\\n while True:\\n epoch += 1\\n epoch_begin = time.time()\\n\\n for batch_examples in train_set.batch_iter(batch_size=args.batch_size, shuffle=True):\\n batch_examples = [e for e in batch_examples if len(e.tgt_actions) <= args.decode_max_time_step]\\n\\n train_iter += 1\\n optimizer.zero_grad()\\n\\n loss = -model.score(batch_examples)\\n # print(loss.data)\\n loss_val = torch.sum(loss).data[0]\\n report_loss += loss_val\\n report_examples += len(batch_examples)\\n loss = torch.mean(loss)\\n\\n loss.backward()\\n\\n # clip gradient\\n if args.clip_grad > 0.:\\n grad_norm = torch.nn.utils.clip_grad_norm(model.parameters(), args.clip_grad)\\n\\n optimizer.step()\\n\\n if train_iter % args.log_every == 0:\\n print('[Iter %d] encoder loss=%.5f' %\\n (train_iter,\\n report_loss / report_examples),\\n file=sys.stderr)\\n\\n report_loss = report_examples = 0.\\n\\n print('[Epoch %d] epoch elapsed %ds' % (epoch, time.time() - epoch_begin), file=sys.stderr)\\n # model_file = args.save_to + '.iter%d.bin' % train_iter\\n # print('save model to [%s]' % model_file, file=sys.stderr)\\n # model.save(model_file)\\n\\n # perform validation\\n print('[Epoch %d] begin validation' % epoch, file=sys.stderr)\\n eval_start = time.time()\\n eval_results = evaluation.evaluate(dev_set.examples, model, args, verbose=True)\\n dev_acc = eval_results['accuracy']\\n print('[Epoch %d] code generation accuracy=%.5f took %ds' % (epoch, dev_acc, time.time() - eval_start), file=sys.stderr)\\n is_better = history_dev_scores == [] or dev_acc > max(history_dev_scores)\\n history_dev_scores.append(dev_acc)\\n\\n if is_better:\\n patience = 0\\n model_file = args.save_to + '.bin'\\n print('save currently the best model ..', file=sys.stderr)\\n print('save model to [%s]' % model_file, file=sys.stderr)\\n model.save(model_file)\\n # also save the optimizers' state\\n torch.save(optimizer.state_dict(), args.save_to + '.optim.bin')\\n elif epoch == args.max_epoch:\\n print('reached max epoch, stop!', file=sys.stderr)\\n exit(0)\\n elif patience < args.patience:\\n patience += 1\\n print('hit patience %d' % patience, file=sys.stderr)\\n\\n if patience == args.patience:\\n num_trial += 1\\n print('hit #%d trial' % num_trial, file=sys.stderr)\\n if num_trial == args.max_num_trial:\\n print('early stop!', file=sys.stderr)\\n exit(0)\\n\\n # decay lr, and restore from previously best checkpoint\\n lr = optimizer.param_groups[0]['lr'] * args.lr_decay\\n print('load previously best model and decay learning rate to %f' % lr, file=sys.stderr)\\n\\n # load model\\n params = torch.load(args.save_to + '.bin', map_location=lambda storage, loc: storage)\\n model.load_state_dict(params['state_dict'])\\n if args.cuda: model = model.cuda()\\n\\n # load optimizers\\n if args.reset_optimizer:\\n print('reset optimizer', file=sys.stderr)\\n optimizer = torch.optim.Adam(model.inference_model.parameters(), lr=lr)\\n else:\\n print('restore parameters of the optimizers', file=sys.stderr)\\n optimizer.load_state_dict(torch.load(args.save_to + '.optim.bin'))\\n\\n # set new lr\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\\n\\n # reset patience\\n patience = 0\",\n \"def initialize_first_model(self, wait=True, input_data_s3_prefix=None):\\n # Sync experiment state if required\\n self._sync_experiment_state_with_ddb()\\n\\n # experiment only allow one training job at a time,\\n # validate no other training request is in progress\\n if (\\n self.experiment_record._training_state is not None\\n and self.experiment_record._training_state.endswith(\\\"ING\\\")\\n ):\\n logger.error(\\n f\\\"A training request with model id '{self.experiment_record._next_model_to_train_id}' \\\"\\n f\\\"was in the state of '{self.experiment_record._training_state}'. \\\"\\n \\\"Wait until the training job finished or canceled the request.\\\"\\n )\\n raise InvalidUsageException(\\n \\\"Please wait for old Training Job to Complete before requesting a new one!\\\"\\n )\\n else:\\n # update next_model_to_train_id and training state\\n next_model_to_train_id = ModelManager.name_next_model(experiment_id=self.experiment_id)\\n logger.info(f\\\"Next Model name would be {next_model_to_train_id}\\\")\\n self.exp_db_client.update_experiment_next_model_to_train_id(\\n self.experiment_id, next_model_to_train_id\\n )\\n self.exp_db_client.update_experiment_training_state(\\n self.experiment_id, TrainingState.PENDING\\n )\\n logger.info(f\\\"Start training job for model '{next_model_to_train_id}''\\\")\\n\\n # generate manifest file if input is a list\\n manifest_file_path = None\\n if isinstance(input_data_s3_prefix, list):\\n # generate manifest file and upload to s3\\n manifest_file_path = self._generate_manifest(input_data_s3_prefix)\\n\\n # init model for training, update model table\\n try:\\n self.next_model_to_train = ModelManager(\\n model_db_client=self.model_db_client,\\n experiment_id=self.experiment_id,\\n model_id=next_model_to_train_id,\\n image=self.image,\\n role=self.resource_manager.iam_role_arn,\\n instance_config=self.resource_manager.training_fleet_config,\\n boto_session=self.boto_session,\\n algor_config=self.algor_config,\\n )\\n\\n self.next_model_to_train.fit(\\n wait=wait,\\n input_model_id=None,\\n input_data_s3_prefix=input_data_s3_prefix,\\n manifest_file_path=manifest_file_path,\\n logs=wait,\\n )\\n except Exception as e:\\n logger.error(\\n f\\\"Failed to start new Model Training job for\\\"\\n \\\" ModelId {next_model_to_train_id}\\\"\\n )\\n logger.error(e)\\n pass\\n\\n # wait until ExperimentDb state is updated\\n if self.local_mode or wait:\\n trained_state = (\\n self.experiment_record._training_state == TrainingState.TRAINED\\n and self.experiment_record._last_trained_model_id == next_model_to_train_id\\n and self.experiment_record._next_model_to_train_id is None\\n )\\n num_retries = 0\\n\\n while not trained_state:\\n # Sync experiment state if required\\n self._sync_experiment_state_with_ddb()\\n logger.debug(\\\"Waiting for experiment table training status to be updated...\\\")\\n time.sleep(2 * (2 ** num_retries))\\n trained_state = (\\n self.experiment_record._training_state == TrainingState.TRAINED\\n and self.experiment_record._last_trained_model_id == next_model_to_train_id\\n and self.experiment_record._next_model_to_train_id is None\\n )\\n num_retries += 1\\n if num_retries >= 5:\\n raise UnhandledWorkflowException(\\n f\\\"Training job '{self.experiment_record._next_model_to_train_id}' \\\"\\n f\\\"was in state of '{self.experiment_record._training_state}'. Expected it to be TRAINED.\\\"\\n )\\n if (\\n self.experiment_record._training_state == TrainingState.FAILED\\n or self.experiment_record._training_state == TrainingState.STOPPED\\n ):\\n raise SageMakerTrainingJobException(\\n f\\\"Training job '{self.experiment_record._next_model_to_train_id}' \\\"\\n f\\\"ended in state of '{self.experiment_record._training_state}'. Please check Sagemaker logs for \\\"\\n \\\"more information.\\\"\\n )\",\n \"def train(self):\\r\\n \\r\\n args = self.args\\r\\n model = self.model\\r\\n dataset = self.dataset\\r\\n train_state = self.train_state\\r\\n optimizer = self.optimizer\\r\\n scheduler = self.scheduler\\r\\n train_bar = self.train_bar\\r\\n val_bar = self.val_bar\\r\\n epoch_bar = self.epoch_bar\\r\\n \\r\\n for epoch_index in range(args.num_epochs):\\r\\n train_state['epoch_index'] = epoch_index\\r\\n \\r\\n # Iterate over training dataset\\r\\n \\r\\n running_loss,running_acc = self.train_loop(epoch_index, args, \\r\\n model, dataset, \\r\\n optimizer, train_bar)\\r\\n \\r\\n train_state['train_loss'].append(running_loss)\\r\\n train_state['train_acc'].append(running_acc)\\r\\n \\r\\n running_loss,running_acc = self.val_loop(epoch_index, args, model, \\r\\n dataset, optimizer, val_bar)\\r\\n \\r\\n \\r\\n train_state['val_loss'].append(running_loss)\\r\\n train_state['val_acc'].append(running_acc)\\r\\n \\r\\n print(\\\"Epoch \\\"+str(epoch_index+1)+\\\": Running loss=\\\"+ \\\\\\r\\n str(running_loss)+\\\", Running Acc=\\\"+str(running_acc))\\r\\n \\r\\n train_state = update_train_state(args=args, model=model, \\r\\n train_state=train_state)\\r\\n \\r\\n scheduler.step(train_state['val_loss'][-1])\\r\\n \\r\\n if train_state['stop_early']:\\r\\n break\\r\\n \\r\\n train_bar.n = 0\\r\\n val_bar.n = 0\\r\\n epoch_bar.set_postfix(best_val=train_state['early_stopping_best_val'] )\\r\\n epoch_bar.update()\\r\\n \\r\\n state_dict = torch.load(train_state['model_filename'])\\r\\n model.load_state_dict(state_dict)\\r\\n return model\",\n \"def _train_model(self):\\n raise NotImplementedError()\",\n \"def train(self, train_loader):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80069077","0.7198703","0.71838933","0.6437247","0.63805366","0.629484","0.62795806","0.6278729","0.62004155","0.6189536","0.6156923","0.6135809","0.61020046","0.6097955","0.60901624","0.60863006","0.60771877","0.6063894","0.6054576","0.6025766","0.60214263","0.6018209","0.60086375","0.6008442","0.59942216","0.5992626","0.5988499","0.5973047","0.59694093","0.5961963","0.5957756","0.59514153","0.5936479","0.5934472","0.59115195","0.5891018","0.58767366","0.5869635","0.58624387","0.5842064","0.5833563","0.58286464","0.58006895","0.57954466","0.5792652","0.5792082","0.5790504","0.5789791","0.5757733","0.5739136","0.573831","0.57371354","0.5731043","0.57306856","0.5720575","0.57117736","0.57060724","0.5703488","0.57025564","0.5694166","0.569338","0.56900203","0.5684658","0.5682842","0.56798774","0.567596","0.56745166","0.56728166","0.5669603","0.5644127","0.5637807","0.5637227","0.56348956","0.5634623","0.56252223","0.56111","0.56109875","0.5608264","0.5602695","0.56012666","0.5599832","0.5594176","0.5591731","0.55907345","0.5590377","0.5590162","0.5584442","0.5583016","0.55790854","0.55756015","0.55753386","0.55749154","0.55745816","0.5571866","0.5571797","0.556916","0.5566739","0.55654883","0.55640507","0.55591756"],"string":"[\n \"0.80069077\",\n \"0.7198703\",\n \"0.71838933\",\n \"0.6437247\",\n \"0.63805366\",\n \"0.629484\",\n \"0.62795806\",\n \"0.6278729\",\n \"0.62004155\",\n \"0.6189536\",\n \"0.6156923\",\n \"0.6135809\",\n \"0.61020046\",\n \"0.6097955\",\n \"0.60901624\",\n \"0.60863006\",\n \"0.60771877\",\n \"0.6063894\",\n \"0.6054576\",\n \"0.6025766\",\n \"0.60214263\",\n \"0.6018209\",\n \"0.60086375\",\n \"0.6008442\",\n \"0.59942216\",\n \"0.5992626\",\n \"0.5988499\",\n \"0.5973047\",\n \"0.59694093\",\n \"0.5961963\",\n \"0.5957756\",\n \"0.59514153\",\n \"0.5936479\",\n \"0.5934472\",\n \"0.59115195\",\n \"0.5891018\",\n \"0.58767366\",\n \"0.5869635\",\n \"0.58624387\",\n \"0.5842064\",\n \"0.5833563\",\n \"0.58286464\",\n \"0.58006895\",\n \"0.57954466\",\n \"0.5792652\",\n \"0.5792082\",\n \"0.5790504\",\n \"0.5789791\",\n \"0.5757733\",\n \"0.5739136\",\n \"0.573831\",\n \"0.57371354\",\n \"0.5731043\",\n \"0.57306856\",\n \"0.5720575\",\n \"0.57117736\",\n \"0.57060724\",\n \"0.5703488\",\n \"0.57025564\",\n \"0.5694166\",\n \"0.569338\",\n \"0.56900203\",\n \"0.5684658\",\n \"0.5682842\",\n \"0.56798774\",\n \"0.567596\",\n \"0.56745166\",\n \"0.56728166\",\n \"0.5669603\",\n \"0.5644127\",\n \"0.5637807\",\n \"0.5637227\",\n \"0.56348956\",\n \"0.5634623\",\n \"0.56252223\",\n \"0.56111\",\n \"0.56109875\",\n \"0.5608264\",\n \"0.5602695\",\n \"0.56012666\",\n \"0.5599832\",\n \"0.5594176\",\n \"0.5591731\",\n \"0.55907345\",\n \"0.5590377\",\n \"0.5590162\",\n \"0.5584442\",\n \"0.5583016\",\n \"0.55790854\",\n \"0.55756015\",\n \"0.55753386\",\n \"0.55749154\",\n \"0.55745816\",\n \"0.5571866\",\n \"0.5571797\",\n \"0.556916\",\n \"0.5566739\",\n \"0.55654883\",\n \"0.55640507\",\n \"0.55591756\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7579028"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14865,"cells":{"query":{"kind":"string","value":"Takes a positive list of integers along with a target and returns a subset of"},"document":{"kind":"string","value":"def diophantine_subset_sum(number_list, target, time_limit=TIME_LIMIT):\n started_at = time.time()\n\n # Sort numbers list.\n number_list = sorted(number_list)\n\n # Build sums list.\n sums_list = [number_list[0]]\n for n in range(1, len(number_list)):\n sums_list.append(number_list[n] + sums_list[n-1])\n\n # Sanity check target.\n if number_list[0] > target or target > sums_list[-1]:\n return []\n\n # Add first subset to subset stack.\n subset_stack = [(len(number_list)-1, target, ())]\n\n # Process subset stack.\n while subset_stack:\n # Enforce time constraint.\n runtime = time.time() - started_at\n if runtime > time_limit:\n raise SummerTimeoutError('No solution found in %d seconds.' % (time_limit))\n\n # Pop first subset off queue\n offset, subtarget, subset = subset_stack.pop()\n\n # Keeps only sums less than subset target.\n sumlist_offset = 0\n while sums_list[sumlist_offset] < subtarget and sumlist_offset < len(sums_list)-1:\n sumlist_offset += 1\n\n # If next sums list value matches subset target, we have a solution.\n if sums_list[sumlist_offset] == subtarget:\n return subset + tuple(number_list[0:sumlist_offset+1])\n\n # Keep only numbers in list less than subset target.\n while number_list[offset] > subtarget and offset > 0:\n offset = offset - 1\n\n # If next number in list matches subset target, we have a solution.\n if number_list[offset] == subtarget:\n return subset + tuple([number_list[offset]])\n\n # Add subsets to queue for any number list values falling between sums list\n # offset and numbers list offset\n step = (sumlist_offset <= offset) and 1 or -1\n for new_offset in range(sumlist_offset, offset+step, step):\n\n new_subset = subset + tuple([number_list[new_offset]])\n new_subtarget = subtarget - number_list[new_offset]\n\n if number_list[0] > new_subtarget:\n break\n\n subset_stack.append((new_offset-1, new_subtarget, new_subset))\n\n # Solution not found\n return []"},"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 _select_sublist(lst, target):\n ln = len(lst)\n\n # Generate an array that indicates the decision bit for each element in the list.\n # If an element is deterministically true, then no decision bit is needed.\n choice_bits = [None] * ln\n x = 0\n for i in range(0, ln):\n if lst[i][1] not in (target.TRUE, target.FALSE):\n choice_bits[i] = x\n x += 1\n\n # We have 2^x distinct lists. Each can be represented as a number between 0 and 2^x-1=n.\n n = (1 << x) - 1\n\n while n >= 0:\n # Generate the list of positive values and node identifiers\n # noinspection PyTypeChecker\n sublist = [lst[i] for i in range(0, ln)\n if (choice_bits[i] is None and lst[i][1] == target.TRUE) or\n (choice_bits[i] is not None and n & 1 << choice_bits[i])]\n # Generate the list of negative node identifiers\n # noinspection PyTypeChecker\n sublist_no = tuple([target.negate(lst[i][1]) for i in range(0, ln)\n if (choice_bits[i] is None and lst[i][1] == target.FALSE) or (\n choice_bits[i] is not None and not n & 1 << choice_bits[i])])\n if sublist:\n terms, nodes = zip(*sublist)\n else:\n # Empty list.\n terms, nodes = (), ()\n yield terms, nodes + sublist_no + (0,)\n n -= 1","def _random_subset(seq,m):\n targets=set()\n while len(targets)<m:\n x=random.choice(seq)\n targets.add(x)\n return targets","def _select_targets(y, min_threshold=10, max_threshold=None):\n c = collections.Counter(y)\n y_sel = []\n for y_id in c:\n if c[y_id] > min_threshold:\n if max_threshold:\n if c[y_id] < max_threshold:\n y_sel.append(y_id)\n else:\n y_sel.append(y_id)\n return y_sel","def _random_subset(seq,m):\n targets=random.sample(seq,m)\n return targets","def select_random_subset(self, input_list):\n import random\n\n random_inp_list = []\n if self.params.advanced.random_sample.number == 0:\n if len(input_list) <= 5:\n random_sample_number = len(input_list)\n elif len(input_list) <= 50:\n random_sample_number = 5\n else:\n random_sample_number = int(len(input_list) * 0.1)\n else:\n random_sample_number = self.params.advanced.random_sample.number\n\n for i in range(random_sample_number):\n random_number = random.randrange(0, len(input_list))\n if input_list[random_number] in random_inp_list:\n while input_list[random_number] in random_inp_list:\n random_number = random.randrange(0, len(input_list))\n random_inp_list.append(input_list[random_number])\n else:\n random_inp_list.append(input_list[random_number])\n\n return random_inp_list","def subrange(x, onset=None, offset=None):\n return (y[(y >= onset) & ~(y > (offset))] for y in x)","def _random_subset(self, pa_nodes, seq, m, rng):\n targets = set()\n while len(targets) < m:\n x = rng.choice(seq)\n # if x in pa_nodes:\n if pa_nodes.get(x, False):\n targets.add(x)\n else:\n pass\n return targets","def _random_subset(seq, m, seed):\n targets = set()\n random.seed(seed)\n\n while len(targets) < m:\n x = random.choice(seq)\n targets.add(x)\n return targets","def searchRange4(self, nums: List[int], target: int) -> List[int]:\n def bisearch_l() -> int:\n i = -1\n l, r = 0, len(nums) - 1\n while l <= r:\n m = (l + r) // 2\n if nums[m] >= target:\n r = m - 1\n else:\n l = m + 1\n \n if nums[m] == target:\n i = m\n \n return i\n\n def bisearch_r() -> int:\n i = -1\n l, r = 0, len(nums) - 1\n while l <= r:\n m = (l + r) // 2\n if nums[m] > target:\n r = m - 1\n else:\n l = m + 1\n \n if nums[m] == target:\n i = m\n \n return i\n\n return [bisearch_l(), bisearch_r()]","def subset_number_to_subset(\n set_size: int,\n subset_size: int,\n subset_number: int,\n order_matters: bool = False,\n can_reselect: bool = False\n) -> List[int]:\n # Sets can't have negative size\n if set_size < 0:\n raise ArithmeticError(f\"Can't have a set of {set_size} items\")\n if subset_size < 0:\n raise ArithmeticError(f\"Can't have a subset of {subset_size} items\")\n\n # Start with the empty set\n subset = []\n\n # The empty set is the only possible subset of size 0, so return it\n if subset_size == 0:\n # Subset number should be 0 for a subset size of 0\n if subset_number != 0:\n raise ArithmeticError(\n f\"0 is the only valid subset number for subsets of size 0, got {subset_number}\"\n )\n\n return subset\n\n # If there are no items to select from, the empty set is the only possible selection,\n # so any subsets of greater size are impossible\n if set_size == 0:\n raise ArithmeticError(\n f\"Can't select a non-empty subset (subset size = {subset_size}) from the empty set\"\n )\n\n # Special case for order-dependent\n if order_matters:\n # Ordered with reselection is shift-encoded, so simply shift-decode\n if can_reselect:\n while len(subset) < subset_size:\n subset.append(subset_number % set_size)\n subset_number //= set_size\n\n # Without reselection, the items available for selection reduces by 1 at each iteration\n else:\n factor = set_size - subset_size + 1\n while len(subset) < subset_size:\n next = subset_number % factor\n subset_number //= factor\n for index in range(len(subset)):\n if subset[index] >= next:\n subset[index] += 1\n subset.insert(0, next)\n factor += 1\n\n return subset\n\n # If reselect is allowed, we are expecting the equivalent binomial representation of the selection\n if can_reselect:\n set_size += subset_size - 1\n subset_size = set_size - subset_size\n\n # Decode the arithmetic encoding of the binomial representation\n num_subsets = number_of_subsets(set_size - 1, subset_size)\n k = subset_size\n for n in reversed(range(set_size)):\n if subset_number >= num_subsets:\n subset_number -= num_subsets\n subset.append(n)\n if len(subset) == subset_size:\n break\n num_subsets = num_subsets * k // n\n k -= 1\n elif n != 0:\n num_subsets = num_subsets * (n - k) // n\n\n # Convert the binomial representation back to the original multinomial one if reselection was enabled\n if can_reselect:\n subset.sort()\n subset_size = set_size - subset_size\n set_size -= subset_size - 1\n counts = {}\n total = 0\n for i in range(set_size - 1):\n last = -1 if i == 0 else subset[i - 1]\n count = subset[i] - last - 1\n total += count\n if count != 0:\n counts[i] = count\n if total < subset_size:\n counts[set_size - 1] = subset_size - total\n subset = []\n for value, count in counts.items():\n for i in range(count):\n subset.append(value)\n\n return subset","def searchRange(self, nums: List[int], target: int) -> List[int]:\n if not nums:\n return [-1, -1]\n n = len(nums)\n start, end = 0, n - 1\n while start <= end:\n mid = start + (end - start + 1 + 1)//2 - 1\n left = right = -1\n if nums[mid] == target:\n left = right = mid\n elif nums[start] == target:\n left = right = start\n elif nums[end] == target:\n left = right = end\n\n if 0 <= left and left < n:\n has_left = left - 1 >= 0 and nums[left-1] == target\n has_right = right + 1 < n and nums[right+1] == target\n while has_left or has_right:\n if has_left:\n left -= 1\n if has_right:\n right += 1\n has_left = left - 1 >= 0 and nums[left-1] == target\n has_right = right + 1 < n and nums[right+1] == target\n\n return [left, right]\n\n elif nums[mid] > target:\n # [0, mid - 1]\n end = mid - 1\n else:\n # [mid + 1, n]\n start = mid + 1\n\n return [-1, -1]","def stratified_subset(features, targets, examples_per_class):\n idxs = np.array([False] * len(features))\n for target in np.unique(targets):\n idxs[np.where(targets == target)[0][:examples_per_class]] = True\n return features[idxs], targets[idxs]","def return_indices(nums, target):\n indices = []\n i = 0\n number_found = False\n while not number_found:\n my_target = nums[i]\n \n for j in range(i+1,len(nums)):\n my_target += nums[j]\n if my_target == target:\n number_found = True\n indices = [i, j]\n break\n my_target = nums[i]\n \n i+=1\n return indices","def list_sum_range_finder(lst, target):\n for n in range(2, len(lst)):\n for sublist in zip(*[lst[x:] for x in range(n)]):\n if sum(sublist) == target:\n return min(sublist) + max(sublist)","def find_value(lists, target):\n loc = []\n l = len(lists)\n for i in range(0, l, 1):\n if(lists[i] == target):\n loc.append(i)\n else:\n continue\n return loc","def coding_problem_42(numbers, target):\n if target == 0:\n return []\n\n valid_numbers = [n for n in numbers if 0 < n <= target]\n for number in sorted(valid_numbers, reverse=True):\n\n remaining_numbers = copy(valid_numbers)\n remaining_numbers.remove(number)\n partial_sum = coding_problem_42(remaining_numbers, target - number)\n if partial_sum is not None:\n return [number] + partial_sum\n\n return None","def get_top_k_indexes_of_list(target_list, k, is_max=True, min_value=None):\n indexes = sorted(range(len(target_list)), key=lambda i: target_list[i], reverse=is_max)[:k]\n result = list()\n if min_value is not None:\n for index in indexes:\n if target_list[index] <= min_value:\n break\n result.append(index)\n else:\n result = indexes\n return result","def discard_none_targets(dataset):\r\n indices = []\r\n for (ii,sample) in enumerate(dataset):\r\n target = sample[1]\r\n if target is not None:\r\n indices.append(ii)\r\n\r\n return Subset(dataset,indices)","def sub(x: list[int], start: int, end: int) -> list[int]:\n result: list[int] = list()\n i: int = 0\n if end > len(x):\n end = len(x)\n if len(x) == 0: \n return result\n else: \n if start > len(x):\n return result\n else: \n if end <= 0:\n return result\n while i < end:\n if i >= start:\n result.append(x[i])\n else: \n if start < 0:\n result.append(x[i])\n i += 1\n return result","def twoSum(self, nums: List[int], target: int) -> List[int]:\n d = {}\n for i, n in enumerate(nums):\n d[n]=i\n \n for i, n in enumerate(nums):\n m = target - n\n if m in d and d[m] != i:\n return [i,d[m]]\n return []","def subset(arr, start, end):\n return [[row_data for row_data in row[start[1]:end[1]]] for row in arr[start[0]:end[0]]]","def recursion(self, size, target, start):\n # Base case:\n if target == 0 and size == 0:\n return [[]]\n \n result = []\n for i in range(start, 10):\n if target - i >= 0 and size - 1 >= 0:\n all_but_i = self.recursion(size - 1, target - i, i + 1)\n # 1. all the combinations in `all_but_i` has size `size` - 1\n # 2. and sums up to `target` - `i`,\n # 3. and the minimum number in each combination is `i` + 1\n for combination in all_but_i:\n result.append([i] + combination)\n # inductive assumption maintained:\n \n # Adding back the number `i`,\n # 1. all the combinations in `result` has size `size`,\n # 2. and sums up to `target`\n # 3. and the minimum number in each combination is `i`\n return result","def select_for_target(self, target):\n\n return [x for x in self.objects if x.target == target]","def compute_random_subset(values, num_values):\n shuffled = values[:]\n random.shuffle(shuffled)\n return shuffled[:num_values]","def adapt_target(self, target):\n\n target = target.view(-1)\n new_target = [target.clone()]\n target_idxs = []\n\n for i in range(len(self.cutoff) - 1):\n mask = target.ge(self.cutoff[i]).mul(target.lt(self.cutoff[i + 1]))\n new_target[0][mask] = self.cutoff[0] + i - self.buggy_offset\n\n if mask.any():\n target_idxs.append(mask.nonzero().squeeze(1))\n new_target.append(target[mask].add(-self.cutoff[i]))\n else:\n target_idxs.append(None)\n new_target.append(None)\n\n return new_target, target_idxs","def prepare_target_list(how_many, target_value):\n target = []\n for one in range(how_many):\n target.append([target_value])\n target = np.array(target)\n return target","def list_validate_number(lst, target):\n elements = set(lst)\n for element in elements:\n if target - element in elements:\n return True\n return False","def subset(mylist,mybool):\n myarray = np.array(mylist)\n return(np.squeeze(myarray.take(np.where(mybool),axis=0)))","def sub(z: list[int], x: int, y: int) -> list[int]:\n i: int = 0\n lists = list()\n end: int = y\n start: int = x\n if len(z) == 0 or end <= 0 or len(z) < start:\n return lists\n elif len(z) < end: \n while len(z) > start:\n lists.append(z[start])\n start += 1 \n return lists\n elif start >= 0: \n while end > start: \n lists.append(z[start])\n start += 1 \n return lists\n elif start < 0: \n while end > i:\n lists.append(z[i])\n i += 1\n return lists\n return z","def get_elements_from_list(target_list, indexes):\n elements = [target_list[i] for i in indexes]\n return elements","def two_sum(self, nums, target):\n\n # idea: for each num, check if it complements a previously seen one\n # (keeping track of them in a dictionary)\n seek = {}\n\n for ind, element in enumerate(nums):\n if element in seek:\n return [seek[element], ind]\n else:\n seek[target - element] = ind\n\n return []","def solution_two(nums, target):\n myHash = {}\n for index, item in enumerate(nums):\n if target - item in nums:\n myHash[index] = item\n\n return list(myHash.keys())","def targets(self, predicate=None):\r\n return filter(predicate, self._targets)","def solutionByOthers(self, nums, target):\n nums.sort()\n results = []\n\n self._findNSum( nums, target, 4, [], results )\n return results","def searchRange(A, target):\n # if len(A) == 0:\n # return [-1,-1]\n # begin = 0\n # end = len(A) - 1\n # if A[end] < target:\n # return [-1, -1]\n # if A[begin] > target:\n # return [-1,-1]\n # while begin <= end:\n # if A[begin] < target:\n # begin += 1\n # elif A[end] > target:\n # end -= 1\n # elif A[begin] >= target:\n # break\n # else:\n # break\n #\n # if A[begin] == A[end]:\n # return [begin, end]\n # else:\n # return [-1,-1]\n\n first = Find_the_first_index(A, target)\n last = Find_the_last_index(A, target)\n return [first, last]","def sel_random(\n l: list,\n f: int = None,\n seed: int = None,\n ) -> list:\n\n # Initialisations\n sel = []\n l_temp = l[:]\n\n # Check if how many numbers to select is not zero\n if f is not None:\n\n # Determine how many numbers to select from the given number\n n_sel = f\n\n else:\n\n if seed is not None:\n\n numpy.random.seed(seed = seed)\n\n # Determine how many numbers to select from the given list\n n_sel = numpy.random.randint(low = 1, high = len(l_temp))\n\n # Loop through the amount of numbers to be selected\n for i in range(0, n_sel):\n\n if seed is not None:\n\n numpy.random.seed(seed = seed + i)\n \n # Select a random number from the list of numbers\n sel.append(numpy.random.choice(numpy.asarray(l_temp)))\n\n # Remove the selected number from the list of numbers to prevent the same number from being selected more than once\n l_temp.remove(sel[i])\n\n # Sort the list of selected numbers\n sel.sort()\n\n return sel","def twoSumSorted1(nums: List[int], target: int) -> List[int]:\n pass","def big_selections(lst: List[int], n: int) -> List[List[int]]:\n if not lst:\n return [[]]\n else:\n holder = [lst.copy()]\n for i in range(len(lst)):\n l2 = lst.copy()\n l2.pop(i)\n for item in selections(l2):\n if item not in holder and sum(item) >= n:\n holder.append(item)\n return holder","def twoSum(self, nums: List[int], target: int) -> List[int]:\n # Use a dict to record visited numbers\n d = {}\n for i, n in enumerate(nums):\n m = target - n\n if m in d:\n return [d[m], i]\n else:\n d[n] = i","def sampleset():\n pos = [(0, i) for i in range(50)]\n neg = [(1, i) for i in range(10)]\n return pos + neg","def subset_of_list(alist, n, t):\n if t < 1 or t > n:\n raise Exception(f't={t} is not accept, must be 1-N (include)')\n\n if n > len(alist): # if n is bigger than all list, return only 1 for t<=len\n if t <= len(alist):\n return [alist[t - 1]]\n else:\n return None\n\n m = int(len(alist) / n) # each task of a section of list\n\n start_index = int((t - 1) * m)\n if t == n:\n sublist = alist[start_index:]\n else:\n sublist = alist[start_index:start_index + m]\n # logger.debug(f'n={n}, t={t}, section={m}, index={start_index}:{start_index + m}')\n return sublist","def get_table_subset(table, batches):\n idxs = np.array([])\n for batch in batches:\n idxs = np.append(idxs, np.where(table['batch'] == batch)[0])\n\n idxs = idxs.astype(int)\n return table.iloc[idxs]","def targeting(enemies_size: int, target: \"list or string\", hits: int):\n if type(target) is not str:\n target *= hits\n elif target == \"ALL\":\n target = list(range(enemies_size))\n if hits > 1:\n extraTarget = target[:]\n for i in range(1, hits):\n target.extend(extraTarget)\n elif target == \"RANDOM\":\n target = []\n for i in range(hits):\n target.append(random.randint(0, enemies_size - 1))\n return target","def sub(a_list: list[int], b: int, c: int) -> list[int]:\n list_returned: list[int] = []\n while len(a_list) == 0:\n if b > len(a_list) or c <= 0:\n return []\n if b < 0:\n list_returned.append(a_list[0])\n else:\n list_returned.append(a_list[b])\n if c > len(a_list):\n list_returned.append(a_list[len(a_list) - 1])\n else:\n list_returned.append(a_list[c - 1])\n return list_returned","def getResult(targets, i=None):","def two_sum(numbers, target):\n already_seen = defaultdict(deque)\n for idx, number in enumerate(numbers):\n complement = target - number\n if complement in already_seen:\n complement_idx = already_seen[complement].popleft()\n return [complement_idx, idx]\n already_seen[number].append(idx)\n raise ValueError('No solution found')","def pick(self, target: int) -> int:\n\t\tans = None\n cnt = 0\n for i, x in enumerate(self.nums): \n if x == target: \n cnt += 1\n if randint(1, cnt) == cnt: ans = i # prob 1/cnt\n return ans","def twoSum(self, nums: List[int], target: int) -> List[int]:\n \n # Given nums=[2,7,11,15],target=9\n \n d={}\n for i in range(len(nums)):\n x = target-nums[i]\n if x in d:\n return [d[x],i]\n\n d[nums[i]]=i\n\n return []","def twoSum(self, nums, target):\n\n seen = {}\n for position, num in enumerate(nums):\n remaining = target - num\n if remaining in seen:\n return [seen[remaining], position]\n seen[num] = position\n return []","def selectRandomSubListFromList(ldata, num):\n\tassertLesser(num, len(ldata), \"size of sublist to be sampled greater than or equal to main list\")\n\ti = randint(0, len(ldata)-1)\n\tsel = ldata[i]\n\tselSet = {i}\n\tselList = [sel]\n\twhile (len(selSet) < num):\n\t\ti = randint(0, len(ldata)-1)\n\t\tif (i not in selSet):\n\t\t\tsel = ldata[i]\n\t\t\tselSet.add(i)\n\t\t\tselList.append(sel)\t\t\n\treturn selList","def x(target: QubitSetInput) -> Iterable[Instruction]:\n return [Instruction(X(), target=qubit) for qubit in QubitSet(target)]","def two_sum(self, nums: List[int], target: int) -> List[int]:\n found = {}\n\n for idx, value in enumerate(nums):\n rest = target - nums[idx]\n if rest in found:\n return [idx, found[rest]]\n else:\n found[value] = idx","def uniform_selection(random, population, args):\r\n num_selected = args.setdefault('num_selected', 1)\r\n selected = []\r\n for _ in range(num_selected):\r\n selected.append(population[random.randint(0, len(population)-1)])\r\n return selected","def pulledsubset(self):\n # compute target subset\n if self.heads is None:\n # We pulled every thing possible\n # sync on everything common\n c = set(self.common)\n ret = list(self.common)\n for n in self.rheads:\n if n not in c:\n ret.append(n)\n return ret\n else:\n # We pulled a specific subset\n # sync on this subset\n return self.heads","def filter_by_for_lists(action_fields, target_list):\n return torch.cat([getattr(b, action_fields) for a in target_list for b in a], dim=0)","def _GetIncrementalQpsTargets(self, target_qps: int) -> list[int]:\n qps = _INCREMENTAL_STARTING_QPS\n result = []\n while qps < target_qps:\n result.append(qps)\n qps *= 1.5\n return result","def select(individuals, n):\r\n # return selBest(individuals, n)\r\n return individuals[:n]","def canSum(lst, target):\n\n return canSumHelper(lst, target, {})","def twoSum(self, nums: List[int], target: int) -> List[int]:\n \n \n idx1 = 0\n idx2 = 1 \n \n while (idx1 != len(nums)-1 ):\n \n if nums[idx1 ] + nums[idx2] == target :\n return [idx1, idx2]\n else :\n \n if idx2 == len(nums)-1:\n idx1=idx1+1\n idx2=idx1+1\n else:\n idx2 = idx2 +1 \n \n \n return [None, None]","def twoSum(self, nums: List[int], target: int) -> List[int]:\n dic = {target-n : i for i, n in enumerate(nums)}\n return next(([i, dic[n]] for i, n in enumerate(nums) if n in dic and i != dic[n]), [0, 0])","def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n n = len(nums)\n ans, res = [], []\n\n for i in range(2**n, 2**(n+1)):\n # generate bitmask, from 0..00 to 1..11\n bitmask = bin(i)[3:]\n res = [nums[j] for j in range(n) if bitmask[j] == '1']\n if res not in ans:\n ans.append(res)\n\n return ans\n # print(ans)","def cut_samples_out( dataSet, fromValue, toValue ):\n newData = []\n for data in dataSet:\n newData.append( [] )\n\n for tup in zip(*dataSet):\n if fromValue <= tup[0] and tup[0] <= toValue:\n for i, val in enumerate( tup ):\n newData[i].append( val )\n \n return newData","def binary_search(alist, target):\n index = binary_search_iterative(alist, target)\n return index","def get_subset(h, k, elements):\n n = len(elements)\n maxM = binom(n, k) - 1\n ans = [0] * k\n a = n\n b = k\n # x is the \"dual\" of h.\n x = maxM - h\n for i in range(0, k):\n ans[i] = largestV(a, b, x)\n x -= binom(ans[i], b)\n a = ans[i]\n b = b - 1\n ans = [elements[(n - 1) - ans[i]] for i in range(0, k)]\n return ans","def confound_restricted_permutations(target, confounds):\n\n raise NotImplementedError()","def getNegativeSamples(target, dataset, K):\n\n indices = [None] * K\n for k in range(K):\n newidx = dataset.sampleTokenIdx()\n while newidx == target:\n newidx = dataset.sampleTokenIdx()\n indices[k] = newidx\n return indices","def getNegativeSamples(target, dataset, K):\n\n indices = [None] * K\n for k in xrange(K):\n newidx = dataset.sampleTokenIdx()\n while newidx == target:\n newidx = dataset.sampleTokenIdx()\n indices[k] = newidx\n return indices","def getNegativeSamples(target, dataset, K):\n\n indices = [None] * K\n for k in xrange(K):\n newidx = dataset.sampleTokenIdx()\n while newidx == target:\n newidx = dataset.sampleTokenIdx()\n indices[k] = newidx\n return indices","def getNegativeSamples(target, dataset, K):\n\n indices = [None] * K\n for k in xrange(K):\n newidx = dataset.sampleTokenIdx()\n while newidx == target:\n newidx = dataset.sampleTokenIdx()\n indices[k] = newidx\n return indices","def two_sum(target, ls):\n complements = set()\n for num in ls:\n if num in complements:\n return True\n complements.add(target - num)\n\n return False","def get_negatives(target, negatives, N, K=5):\n res = np.random.choice(negatives, size=(N, K))\n for i in range(len(res)):\n for j in range(K):\n if res[i, j] == target[i]:\n res[i, j] = np.random.choice(negatives, size=1)\n\n return res","def get_for_target(self, target):\n return self.get_for_targets([target])","def genSubset(L):\n if len(L) == 0:\n return [[]] # list of empty list\n smaller = genSubset(L[:-1]) # the list without last element\n extra = L[-1:] # a list of just the last element\n new = []\n for small in smaller:\n new.append(small + extra)\n return smaller + new","def subsets(arr):\n return chain(*[combinations(arr, i + 1) for i, a in enumerate(arr)])","def subsets(arr):\n return chain(*[combinations(arr, i + 1) for i, a in enumerate(arr)])","def genSubset2(L):\n import itertools\n result = []\n for i in range(len(L) + 1):\n result += list(itertools.combinations(L, i))\n return result","def batch(source, target):\r\n indices = np.random.choice(range(source.shape[0]), size=BATCH_SIZE)\r\n source = np.take(source, indices, axis=0)\r\n target = np.take(target, indices, axis=0)\r\n return (source, target)","def get_pool_subset(X_pool, Y_pool, subset_size=2000):\n subset_indices = np.asarray(random.sample(range(0,X_pool.shape[0]), subset_size))\n X_pool_subset = X_pool[subset_indices]\n Y_pool_subset = Y_pool[subset_indices]\n X_pool = np.delete(X_pool, subset_indices, axis=0)\n Y_pool = np.delete(Y_pool, subset_indices, axis=0)\n return (X_pool, Y_pool), (X_pool_subset, Y_pool_subset)","def __get_min_indexes(num_list, number):\n result = []\n\n num_list = np.array(num_list)\n result = np.argpartition(num_list, number)[:number]\n\n return result","def get_subset(self, start=None, end=None):\n \n if start is None and end is None:\n return self.img_lst\n elif start is None:\n return self.img_lst[:end]\n elif end is None:\n return self.img_lst[start:]\n else:\n return self.img_lst[start:end]","def get_relevant_indices(dataset, classes, target_classes):\n indices = []\n for i in range(len(dataset)):\n # Check if the label is in the target classes\n label_index = dataset[i][1] # ex: 3\n label_class = classes[label_index] # ex: 'cat'\n if label_class in target_classes:\n indices.append(i)\n return indices","def bin_search(target, low, high, int_list): # must use recursion\n if int_list == None:\n raise ValueError\n if high < low: # returns None if target is not found\n return None\n midpoint = (high + low) // 2\n if int_list[midpoint] == target:\n return midpoint\n elif target < int_list[midpoint]: # when target is lower than midpoint\n return bin_search(target, low, midpoint - 1, int_list)\n elif target > int_list[midpoint]: # when target is greater than midpoint\n return bin_search(target, midpoint + 1, high, int_list)","def twoSum(self, nums, target):\n for index_i, i in enumerate(nums):\n for index_j, j in enumerate(nums[index_i+1:]):\n if j + i == target:\n return [index_i + 1, index_j + index_i + 2]","def Collection_select_cheap(C:list, n: float)->list:\r\n result = []\r\n for rest in C:\r\n if Restaurant_is_cheap(rest, n) == True:\r\n result.append(rest)\r\n return result","def _subset(lst: list, val_filter: str) -> int:\n \n for i, v in enumerate(lst):\n if v == val_filter:\n return i","def get_for_targets(self, targets):\n products = OrderedSet()\n for target in targets:\n products.update(self._products_by_target[target])\n return products","def twoSum(self, nums: List[int], target: int) -> List[int]:\n diffRec = {}\n for i, v in enumerate(nums):\n if v in diffRec:\n return [diffRec[v], i]\n else:\n diffRec[target - v] = i\n return -1","def bin_search(target, low, high, int_list): # must use recursion\n if int_list == None:\n raise ValueError\n if len(int_list) == 0:\n return None\n middle = (low + high) // 2\n if low > high or low < 0 or high > len(int_list):\n return None\n elif int_list[middle] == target:\n return middle \n elif int_list[middle] > target: \n return bin_search(target, low, middle - 1, int_list)\n else:\n return bin_search(target, middle + 1, high, int_list)","def selectRandomSubListFromListWithRepl(ldata, num):\n\treturn list(map(lambda i : selectRandomFromList(ldata), range(num)))","def bin_search(target, low, high, int_list): # must use recursion\n if int_list == None:\n raise ValueError(\"Must be a list\")\n \n middle = (low + high) // 2\n if low > high:\n return None\n if int_list[middle] > target:\n return bin_search(target, low, middle - 1, int_list)\n if int_list[middle] < target:\n return bin_search(target, middle + 1, high, int_list)\n return middle","def find_index(vec_vals,target):\n target=np.atleast_1d(target) #turn scalar into iterable, no op if already array\n vec_vals=np.array(vec_vals)\n index_list=[]\n for item in target:\n first_index=np.argmin(np.abs(vec_vals - item))\n index_list.append(first_index)\n return index_list","def uniform_select(xs):\n n = len(xs) - 1\n i = randint(0, n)\n return xs[i]","def s(target: QubitSetInput) -> Iterable[Instruction]:\n return [Instruction(S(), target=qubit) for qubit in QubitSet(target)]","def random_choice_no_return(arr, num_lst):\r\n num_lst_arr = np.array(num_lst)\r\n num_sum = num_lst_arr.sum()\r\n if type(arr) == list:\r\n arr = np.array(arr)\r\n assert num_sum <= arr.size\r\n results = []\r\n arr_residue = np.arange(arr.size)\r\n for num in num_lst_arr:\r\n idx_chosen = np.random.choice(arr_residue.size, num, replace=False)\r\n chosen_idx_in_arr = np.sort(arr_residue[idx_chosen])\r\n results.append(arr[chosen_idx_in_arr])\r\n arr_residue = np.delete(arr_residue, idx_chosen)\r\n return results","def filter_by_subset(self, *args):\n self.subset_labels = sorted(set(self.subset_labels + list(args)))\n return self","def selections(xs):\n for i, x in enumerate(xs):\n yield (x, xs[:i] + xs[i + 1:])","def minOperations(self, target: list[int], arr: list[int]) -> int:\n orders = {x: i for i, x in enumerate(target)}\n stack = []\n for x in arr:\n if x not in orders:\n continue\n\n i = bisect_left(stack, orders[x])\n if i == len(stack):\n stack.append(0)\n\n stack[i] = orders[x]\n\n return len(target) - len(stack)","def run(self, target: int) -> list:\n\n valid_values = range(0, 99)\n\n # This will be some sort of brute force attempt\n values = [0, 0]\n while values[0] < 100 and values[1] < 100:\n self.reset()\n# import pdb; pdb.set_trace()\n test = self._process(values[0], values[1])\n if test == target:\n break\n else:\n if values[0] <= 99:\n if values[1] < 99:\n values[1] += 1\n elif values[1] == 99 and values[0] < 99:\n values[0] += 1\n values[1] = 0\n\n else:\n raise OpCodeError(\"No value possible\")\n\n return 100 * values[0] + values[1]","def get_random_indexes(msk, n_idxs):\n pos_idxs = np.array(np.where(msk > 0))\n neg_idxs = np.array(np.where(msk == 0))\n n_pos = pos_idxs.shape[1] # number of positives found in the mask\n n_neg = neg_idxs.shape[1] # number of negatives found in the mask\n n_min = min(n_neg, min(n_idxs, n_pos))\n rnd_idxs_pos = range(n_pos)\n np.random.shuffle(rnd_idxs_pos)\n rnd_idxs_neg = range(n_neg)\n np.random.shuffle(rnd_idxs_neg)\n return pos_idxs[:, rnd_idxs_pos[:n_min]], neg_idxs[:, rnd_idxs_neg[:n_min]]","def t(target: QubitSetInput) -> Iterable[Instruction]:\n return [Instruction(T(), target=qubit) for qubit in QubitSet(target)]"],"string":"[\n \"def _select_sublist(lst, target):\\n ln = len(lst)\\n\\n # Generate an array that indicates the decision bit for each element in the list.\\n # If an element is deterministically true, then no decision bit is needed.\\n choice_bits = [None] * ln\\n x = 0\\n for i in range(0, ln):\\n if lst[i][1] not in (target.TRUE, target.FALSE):\\n choice_bits[i] = x\\n x += 1\\n\\n # We have 2^x distinct lists. Each can be represented as a number between 0 and 2^x-1=n.\\n n = (1 << x) - 1\\n\\n while n >= 0:\\n # Generate the list of positive values and node identifiers\\n # noinspection PyTypeChecker\\n sublist = [lst[i] for i in range(0, ln)\\n if (choice_bits[i] is None and lst[i][1] == target.TRUE) or\\n (choice_bits[i] is not None and n & 1 << choice_bits[i])]\\n # Generate the list of negative node identifiers\\n # noinspection PyTypeChecker\\n sublist_no = tuple([target.negate(lst[i][1]) for i in range(0, ln)\\n if (choice_bits[i] is None and lst[i][1] == target.FALSE) or (\\n choice_bits[i] is not None and not n & 1 << choice_bits[i])])\\n if sublist:\\n terms, nodes = zip(*sublist)\\n else:\\n # Empty list.\\n terms, nodes = (), ()\\n yield terms, nodes + sublist_no + (0,)\\n n -= 1\",\n \"def _random_subset(seq,m):\\n targets=set()\\n while len(targets)<m:\\n x=random.choice(seq)\\n targets.add(x)\\n return targets\",\n \"def _select_targets(y, min_threshold=10, max_threshold=None):\\n c = collections.Counter(y)\\n y_sel = []\\n for y_id in c:\\n if c[y_id] > min_threshold:\\n if max_threshold:\\n if c[y_id] < max_threshold:\\n y_sel.append(y_id)\\n else:\\n y_sel.append(y_id)\\n return y_sel\",\n \"def _random_subset(seq,m):\\n targets=random.sample(seq,m)\\n return targets\",\n \"def select_random_subset(self, input_list):\\n import random\\n\\n random_inp_list = []\\n if self.params.advanced.random_sample.number == 0:\\n if len(input_list) <= 5:\\n random_sample_number = len(input_list)\\n elif len(input_list) <= 50:\\n random_sample_number = 5\\n else:\\n random_sample_number = int(len(input_list) * 0.1)\\n else:\\n random_sample_number = self.params.advanced.random_sample.number\\n\\n for i in range(random_sample_number):\\n random_number = random.randrange(0, len(input_list))\\n if input_list[random_number] in random_inp_list:\\n while input_list[random_number] in random_inp_list:\\n random_number = random.randrange(0, len(input_list))\\n random_inp_list.append(input_list[random_number])\\n else:\\n random_inp_list.append(input_list[random_number])\\n\\n return random_inp_list\",\n \"def subrange(x, onset=None, offset=None):\\n return (y[(y >= onset) & ~(y > (offset))] for y in x)\",\n \"def _random_subset(self, pa_nodes, seq, m, rng):\\n targets = set()\\n while len(targets) < m:\\n x = rng.choice(seq)\\n # if x in pa_nodes:\\n if pa_nodes.get(x, False):\\n targets.add(x)\\n else:\\n pass\\n return targets\",\n \"def _random_subset(seq, m, seed):\\n targets = set()\\n random.seed(seed)\\n\\n while len(targets) < m:\\n x = random.choice(seq)\\n targets.add(x)\\n return targets\",\n \"def searchRange4(self, nums: List[int], target: int) -> List[int]:\\n def bisearch_l() -> int:\\n i = -1\\n l, r = 0, len(nums) - 1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[m] >= target:\\n r = m - 1\\n else:\\n l = m + 1\\n \\n if nums[m] == target:\\n i = m\\n \\n return i\\n\\n def bisearch_r() -> int:\\n i = -1\\n l, r = 0, len(nums) - 1\\n while l <= r:\\n m = (l + r) // 2\\n if nums[m] > target:\\n r = m - 1\\n else:\\n l = m + 1\\n \\n if nums[m] == target:\\n i = m\\n \\n return i\\n\\n return [bisearch_l(), bisearch_r()]\",\n \"def subset_number_to_subset(\\n set_size: int,\\n subset_size: int,\\n subset_number: int,\\n order_matters: bool = False,\\n can_reselect: bool = False\\n) -> List[int]:\\n # Sets can't have negative size\\n if set_size < 0:\\n raise ArithmeticError(f\\\"Can't have a set of {set_size} items\\\")\\n if subset_size < 0:\\n raise ArithmeticError(f\\\"Can't have a subset of {subset_size} items\\\")\\n\\n # Start with the empty set\\n subset = []\\n\\n # The empty set is the only possible subset of size 0, so return it\\n if subset_size == 0:\\n # Subset number should be 0 for a subset size of 0\\n if subset_number != 0:\\n raise ArithmeticError(\\n f\\\"0 is the only valid subset number for subsets of size 0, got {subset_number}\\\"\\n )\\n\\n return subset\\n\\n # If there are no items to select from, the empty set is the only possible selection,\\n # so any subsets of greater size are impossible\\n if set_size == 0:\\n raise ArithmeticError(\\n f\\\"Can't select a non-empty subset (subset size = {subset_size}) from the empty set\\\"\\n )\\n\\n # Special case for order-dependent\\n if order_matters:\\n # Ordered with reselection is shift-encoded, so simply shift-decode\\n if can_reselect:\\n while len(subset) < subset_size:\\n subset.append(subset_number % set_size)\\n subset_number //= set_size\\n\\n # Without reselection, the items available for selection reduces by 1 at each iteration\\n else:\\n factor = set_size - subset_size + 1\\n while len(subset) < subset_size:\\n next = subset_number % factor\\n subset_number //= factor\\n for index in range(len(subset)):\\n if subset[index] >= next:\\n subset[index] += 1\\n subset.insert(0, next)\\n factor += 1\\n\\n return subset\\n\\n # If reselect is allowed, we are expecting the equivalent binomial representation of the selection\\n if can_reselect:\\n set_size += subset_size - 1\\n subset_size = set_size - subset_size\\n\\n # Decode the arithmetic encoding of the binomial representation\\n num_subsets = number_of_subsets(set_size - 1, subset_size)\\n k = subset_size\\n for n in reversed(range(set_size)):\\n if subset_number >= num_subsets:\\n subset_number -= num_subsets\\n subset.append(n)\\n if len(subset) == subset_size:\\n break\\n num_subsets = num_subsets * k // n\\n k -= 1\\n elif n != 0:\\n num_subsets = num_subsets * (n - k) // n\\n\\n # Convert the binomial representation back to the original multinomial one if reselection was enabled\\n if can_reselect:\\n subset.sort()\\n subset_size = set_size - subset_size\\n set_size -= subset_size - 1\\n counts = {}\\n total = 0\\n for i in range(set_size - 1):\\n last = -1 if i == 0 else subset[i - 1]\\n count = subset[i] - last - 1\\n total += count\\n if count != 0:\\n counts[i] = count\\n if total < subset_size:\\n counts[set_size - 1] = subset_size - total\\n subset = []\\n for value, count in counts.items():\\n for i in range(count):\\n subset.append(value)\\n\\n return subset\",\n \"def searchRange(self, nums: List[int], target: int) -> List[int]:\\n if not nums:\\n return [-1, -1]\\n n = len(nums)\\n start, end = 0, n - 1\\n while start <= end:\\n mid = start + (end - start + 1 + 1)//2 - 1\\n left = right = -1\\n if nums[mid] == target:\\n left = right = mid\\n elif nums[start] == target:\\n left = right = start\\n elif nums[end] == target:\\n left = right = end\\n\\n if 0 <= left and left < n:\\n has_left = left - 1 >= 0 and nums[left-1] == target\\n has_right = right + 1 < n and nums[right+1] == target\\n while has_left or has_right:\\n if has_left:\\n left -= 1\\n if has_right:\\n right += 1\\n has_left = left - 1 >= 0 and nums[left-1] == target\\n has_right = right + 1 < n and nums[right+1] == target\\n\\n return [left, right]\\n\\n elif nums[mid] > target:\\n # [0, mid - 1]\\n end = mid - 1\\n else:\\n # [mid + 1, n]\\n start = mid + 1\\n\\n return [-1, -1]\",\n \"def stratified_subset(features, targets, examples_per_class):\\n idxs = np.array([False] * len(features))\\n for target in np.unique(targets):\\n idxs[np.where(targets == target)[0][:examples_per_class]] = True\\n return features[idxs], targets[idxs]\",\n \"def return_indices(nums, target):\\n indices = []\\n i = 0\\n number_found = False\\n while not number_found:\\n my_target = nums[i]\\n \\n for j in range(i+1,len(nums)):\\n my_target += nums[j]\\n if my_target == target:\\n number_found = True\\n indices = [i, j]\\n break\\n my_target = nums[i]\\n \\n i+=1\\n return indices\",\n \"def list_sum_range_finder(lst, target):\\n for n in range(2, len(lst)):\\n for sublist in zip(*[lst[x:] for x in range(n)]):\\n if sum(sublist) == target:\\n return min(sublist) + max(sublist)\",\n \"def find_value(lists, target):\\n loc = []\\n l = len(lists)\\n for i in range(0, l, 1):\\n if(lists[i] == target):\\n loc.append(i)\\n else:\\n continue\\n return loc\",\n \"def coding_problem_42(numbers, target):\\n if target == 0:\\n return []\\n\\n valid_numbers = [n for n in numbers if 0 < n <= target]\\n for number in sorted(valid_numbers, reverse=True):\\n\\n remaining_numbers = copy(valid_numbers)\\n remaining_numbers.remove(number)\\n partial_sum = coding_problem_42(remaining_numbers, target - number)\\n if partial_sum is not None:\\n return [number] + partial_sum\\n\\n return None\",\n \"def get_top_k_indexes_of_list(target_list, k, is_max=True, min_value=None):\\n indexes = sorted(range(len(target_list)), key=lambda i: target_list[i], reverse=is_max)[:k]\\n result = list()\\n if min_value is not None:\\n for index in indexes:\\n if target_list[index] <= min_value:\\n break\\n result.append(index)\\n else:\\n result = indexes\\n return result\",\n \"def discard_none_targets(dataset):\\r\\n indices = []\\r\\n for (ii,sample) in enumerate(dataset):\\r\\n target = sample[1]\\r\\n if target is not None:\\r\\n indices.append(ii)\\r\\n\\r\\n return Subset(dataset,indices)\",\n \"def sub(x: list[int], start: int, end: int) -> list[int]:\\n result: list[int] = list()\\n i: int = 0\\n if end > len(x):\\n end = len(x)\\n if len(x) == 0: \\n return result\\n else: \\n if start > len(x):\\n return result\\n else: \\n if end <= 0:\\n return result\\n while i < end:\\n if i >= start:\\n result.append(x[i])\\n else: \\n if start < 0:\\n result.append(x[i])\\n i += 1\\n return result\",\n \"def twoSum(self, nums: List[int], target: int) -> List[int]:\\n d = {}\\n for i, n in enumerate(nums):\\n d[n]=i\\n \\n for i, n in enumerate(nums):\\n m = target - n\\n if m in d and d[m] != i:\\n return [i,d[m]]\\n return []\",\n \"def subset(arr, start, end):\\n return [[row_data for row_data in row[start[1]:end[1]]] for row in arr[start[0]:end[0]]]\",\n \"def recursion(self, size, target, start):\\n # Base case:\\n if target == 0 and size == 0:\\n return [[]]\\n \\n result = []\\n for i in range(start, 10):\\n if target - i >= 0 and size - 1 >= 0:\\n all_but_i = self.recursion(size - 1, target - i, i + 1)\\n # 1. all the combinations in `all_but_i` has size `size` - 1\\n # 2. and sums up to `target` - `i`,\\n # 3. and the minimum number in each combination is `i` + 1\\n for combination in all_but_i:\\n result.append([i] + combination)\\n # inductive assumption maintained:\\n \\n # Adding back the number `i`,\\n # 1. all the combinations in `result` has size `size`,\\n # 2. and sums up to `target`\\n # 3. and the minimum number in each combination is `i`\\n return result\",\n \"def select_for_target(self, target):\\n\\n return [x for x in self.objects if x.target == target]\",\n \"def compute_random_subset(values, num_values):\\n shuffled = values[:]\\n random.shuffle(shuffled)\\n return shuffled[:num_values]\",\n \"def adapt_target(self, target):\\n\\n target = target.view(-1)\\n new_target = [target.clone()]\\n target_idxs = []\\n\\n for i in range(len(self.cutoff) - 1):\\n mask = target.ge(self.cutoff[i]).mul(target.lt(self.cutoff[i + 1]))\\n new_target[0][mask] = self.cutoff[0] + i - self.buggy_offset\\n\\n if mask.any():\\n target_idxs.append(mask.nonzero().squeeze(1))\\n new_target.append(target[mask].add(-self.cutoff[i]))\\n else:\\n target_idxs.append(None)\\n new_target.append(None)\\n\\n return new_target, target_idxs\",\n \"def prepare_target_list(how_many, target_value):\\n target = []\\n for one in range(how_many):\\n target.append([target_value])\\n target = np.array(target)\\n return target\",\n \"def list_validate_number(lst, target):\\n elements = set(lst)\\n for element in elements:\\n if target - element in elements:\\n return True\\n return False\",\n \"def subset(mylist,mybool):\\n myarray = np.array(mylist)\\n return(np.squeeze(myarray.take(np.where(mybool),axis=0)))\",\n \"def sub(z: list[int], x: int, y: int) -> list[int]:\\n i: int = 0\\n lists = list()\\n end: int = y\\n start: int = x\\n if len(z) == 0 or end <= 0 or len(z) < start:\\n return lists\\n elif len(z) < end: \\n while len(z) > start:\\n lists.append(z[start])\\n start += 1 \\n return lists\\n elif start >= 0: \\n while end > start: \\n lists.append(z[start])\\n start += 1 \\n return lists\\n elif start < 0: \\n while end > i:\\n lists.append(z[i])\\n i += 1\\n return lists\\n return z\",\n \"def get_elements_from_list(target_list, indexes):\\n elements = [target_list[i] for i in indexes]\\n return elements\",\n \"def two_sum(self, nums, target):\\n\\n # idea: for each num, check if it complements a previously seen one\\n # (keeping track of them in a dictionary)\\n seek = {}\\n\\n for ind, element in enumerate(nums):\\n if element in seek:\\n return [seek[element], ind]\\n else:\\n seek[target - element] = ind\\n\\n return []\",\n \"def solution_two(nums, target):\\n myHash = {}\\n for index, item in enumerate(nums):\\n if target - item in nums:\\n myHash[index] = item\\n\\n return list(myHash.keys())\",\n \"def targets(self, predicate=None):\\r\\n return filter(predicate, self._targets)\",\n \"def solutionByOthers(self, nums, target):\\n nums.sort()\\n results = []\\n\\n self._findNSum( nums, target, 4, [], results )\\n return results\",\n \"def searchRange(A, target):\\n # if len(A) == 0:\\n # return [-1,-1]\\n # begin = 0\\n # end = len(A) - 1\\n # if A[end] < target:\\n # return [-1, -1]\\n # if A[begin] > target:\\n # return [-1,-1]\\n # while begin <= end:\\n # if A[begin] < target:\\n # begin += 1\\n # elif A[end] > target:\\n # end -= 1\\n # elif A[begin] >= target:\\n # break\\n # else:\\n # break\\n #\\n # if A[begin] == A[end]:\\n # return [begin, end]\\n # else:\\n # return [-1,-1]\\n\\n first = Find_the_first_index(A, target)\\n last = Find_the_last_index(A, target)\\n return [first, last]\",\n \"def sel_random(\\n l: list,\\n f: int = None,\\n seed: int = None,\\n ) -> list:\\n\\n # Initialisations\\n sel = []\\n l_temp = l[:]\\n\\n # Check if how many numbers to select is not zero\\n if f is not None:\\n\\n # Determine how many numbers to select from the given number\\n n_sel = f\\n\\n else:\\n\\n if seed is not None:\\n\\n numpy.random.seed(seed = seed)\\n\\n # Determine how many numbers to select from the given list\\n n_sel = numpy.random.randint(low = 1, high = len(l_temp))\\n\\n # Loop through the amount of numbers to be selected\\n for i in range(0, n_sel):\\n\\n if seed is not None:\\n\\n numpy.random.seed(seed = seed + i)\\n \\n # Select a random number from the list of numbers\\n sel.append(numpy.random.choice(numpy.asarray(l_temp)))\\n\\n # Remove the selected number from the list of numbers to prevent the same number from being selected more than once\\n l_temp.remove(sel[i])\\n\\n # Sort the list of selected numbers\\n sel.sort()\\n\\n return sel\",\n \"def twoSumSorted1(nums: List[int], target: int) -> List[int]:\\n pass\",\n \"def big_selections(lst: List[int], n: int) -> List[List[int]]:\\n if not lst:\\n return [[]]\\n else:\\n holder = [lst.copy()]\\n for i in range(len(lst)):\\n l2 = lst.copy()\\n l2.pop(i)\\n for item in selections(l2):\\n if item not in holder and sum(item) >= n:\\n holder.append(item)\\n return holder\",\n \"def twoSum(self, nums: List[int], target: int) -> List[int]:\\n # Use a dict to record visited numbers\\n d = {}\\n for i, n in enumerate(nums):\\n m = target - n\\n if m in d:\\n return [d[m], i]\\n else:\\n d[n] = i\",\n \"def sampleset():\\n pos = [(0, i) for i in range(50)]\\n neg = [(1, i) for i in range(10)]\\n return pos + neg\",\n \"def subset_of_list(alist, n, t):\\n if t < 1 or t > n:\\n raise Exception(f't={t} is not accept, must be 1-N (include)')\\n\\n if n > len(alist): # if n is bigger than all list, return only 1 for t<=len\\n if t <= len(alist):\\n return [alist[t - 1]]\\n else:\\n return None\\n\\n m = int(len(alist) / n) # each task of a section of list\\n\\n start_index = int((t - 1) * m)\\n if t == n:\\n sublist = alist[start_index:]\\n else:\\n sublist = alist[start_index:start_index + m]\\n # logger.debug(f'n={n}, t={t}, section={m}, index={start_index}:{start_index + m}')\\n return sublist\",\n \"def get_table_subset(table, batches):\\n idxs = np.array([])\\n for batch in batches:\\n idxs = np.append(idxs, np.where(table['batch'] == batch)[0])\\n\\n idxs = idxs.astype(int)\\n return table.iloc[idxs]\",\n \"def targeting(enemies_size: int, target: \\\"list or string\\\", hits: int):\\n if type(target) is not str:\\n target *= hits\\n elif target == \\\"ALL\\\":\\n target = list(range(enemies_size))\\n if hits > 1:\\n extraTarget = target[:]\\n for i in range(1, hits):\\n target.extend(extraTarget)\\n elif target == \\\"RANDOM\\\":\\n target = []\\n for i in range(hits):\\n target.append(random.randint(0, enemies_size - 1))\\n return target\",\n \"def sub(a_list: list[int], b: int, c: int) -> list[int]:\\n list_returned: list[int] = []\\n while len(a_list) == 0:\\n if b > len(a_list) or c <= 0:\\n return []\\n if b < 0:\\n list_returned.append(a_list[0])\\n else:\\n list_returned.append(a_list[b])\\n if c > len(a_list):\\n list_returned.append(a_list[len(a_list) - 1])\\n else:\\n list_returned.append(a_list[c - 1])\\n return list_returned\",\n \"def getResult(targets, i=None):\",\n \"def two_sum(numbers, target):\\n already_seen = defaultdict(deque)\\n for idx, number in enumerate(numbers):\\n complement = target - number\\n if complement in already_seen:\\n complement_idx = already_seen[complement].popleft()\\n return [complement_idx, idx]\\n already_seen[number].append(idx)\\n raise ValueError('No solution found')\",\n \"def pick(self, target: int) -> int:\\n\\t\\tans = None\\n cnt = 0\\n for i, x in enumerate(self.nums): \\n if x == target: \\n cnt += 1\\n if randint(1, cnt) == cnt: ans = i # prob 1/cnt\\n return ans\",\n \"def twoSum(self, nums: List[int], target: int) -> List[int]:\\n \\n # Given nums=[2,7,11,15],target=9\\n \\n d={}\\n for i in range(len(nums)):\\n x = target-nums[i]\\n if x in d:\\n return [d[x],i]\\n\\n d[nums[i]]=i\\n\\n return []\",\n \"def twoSum(self, nums, target):\\n\\n seen = {}\\n for position, num in enumerate(nums):\\n remaining = target - num\\n if remaining in seen:\\n return [seen[remaining], position]\\n seen[num] = position\\n return []\",\n \"def selectRandomSubListFromList(ldata, num):\\n\\tassertLesser(num, len(ldata), \\\"size of sublist to be sampled greater than or equal to main list\\\")\\n\\ti = randint(0, len(ldata)-1)\\n\\tsel = ldata[i]\\n\\tselSet = {i}\\n\\tselList = [sel]\\n\\twhile (len(selSet) < num):\\n\\t\\ti = randint(0, len(ldata)-1)\\n\\t\\tif (i not in selSet):\\n\\t\\t\\tsel = ldata[i]\\n\\t\\t\\tselSet.add(i)\\n\\t\\t\\tselList.append(sel)\\t\\t\\n\\treturn selList\",\n \"def x(target: QubitSetInput) -> Iterable[Instruction]:\\n return [Instruction(X(), target=qubit) for qubit in QubitSet(target)]\",\n \"def two_sum(self, nums: List[int], target: int) -> List[int]:\\n found = {}\\n\\n for idx, value in enumerate(nums):\\n rest = target - nums[idx]\\n if rest in found:\\n return [idx, found[rest]]\\n else:\\n found[value] = idx\",\n \"def uniform_selection(random, population, args):\\r\\n num_selected = args.setdefault('num_selected', 1)\\r\\n selected = []\\r\\n for _ in range(num_selected):\\r\\n selected.append(population[random.randint(0, len(population)-1)])\\r\\n return selected\",\n \"def pulledsubset(self):\\n # compute target subset\\n if self.heads is None:\\n # We pulled every thing possible\\n # sync on everything common\\n c = set(self.common)\\n ret = list(self.common)\\n for n in self.rheads:\\n if n not in c:\\n ret.append(n)\\n return ret\\n else:\\n # We pulled a specific subset\\n # sync on this subset\\n return self.heads\",\n \"def filter_by_for_lists(action_fields, target_list):\\n return torch.cat([getattr(b, action_fields) for a in target_list for b in a], dim=0)\",\n \"def _GetIncrementalQpsTargets(self, target_qps: int) -> list[int]:\\n qps = _INCREMENTAL_STARTING_QPS\\n result = []\\n while qps < target_qps:\\n result.append(qps)\\n qps *= 1.5\\n return result\",\n \"def select(individuals, n):\\r\\n # return selBest(individuals, n)\\r\\n return individuals[:n]\",\n \"def canSum(lst, target):\\n\\n return canSumHelper(lst, target, {})\",\n \"def twoSum(self, nums: List[int], target: int) -> List[int]:\\n \\n \\n idx1 = 0\\n idx2 = 1 \\n \\n while (idx1 != len(nums)-1 ):\\n \\n if nums[idx1 ] + nums[idx2] == target :\\n return [idx1, idx2]\\n else :\\n \\n if idx2 == len(nums)-1:\\n idx1=idx1+1\\n idx2=idx1+1\\n else:\\n idx2 = idx2 +1 \\n \\n \\n return [None, None]\",\n \"def twoSum(self, nums: List[int], target: int) -> List[int]:\\n dic = {target-n : i for i, n in enumerate(nums)}\\n return next(([i, dic[n]] for i, n in enumerate(nums) if n in dic and i != dic[n]), [0, 0])\",\n \"def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:\\n nums.sort()\\n n = len(nums)\\n ans, res = [], []\\n\\n for i in range(2**n, 2**(n+1)):\\n # generate bitmask, from 0..00 to 1..11\\n bitmask = bin(i)[3:]\\n res = [nums[j] for j in range(n) if bitmask[j] == '1']\\n if res not in ans:\\n ans.append(res)\\n\\n return ans\\n # print(ans)\",\n \"def cut_samples_out( dataSet, fromValue, toValue ):\\n newData = []\\n for data in dataSet:\\n newData.append( [] )\\n\\n for tup in zip(*dataSet):\\n if fromValue <= tup[0] and tup[0] <= toValue:\\n for i, val in enumerate( tup ):\\n newData[i].append( val )\\n \\n return newData\",\n \"def binary_search(alist, target):\\n index = binary_search_iterative(alist, target)\\n return index\",\n \"def get_subset(h, k, elements):\\n n = len(elements)\\n maxM = binom(n, k) - 1\\n ans = [0] * k\\n a = n\\n b = k\\n # x is the \\\"dual\\\" of h.\\n x = maxM - h\\n for i in range(0, k):\\n ans[i] = largestV(a, b, x)\\n x -= binom(ans[i], b)\\n a = ans[i]\\n b = b - 1\\n ans = [elements[(n - 1) - ans[i]] for i in range(0, k)]\\n return ans\",\n \"def confound_restricted_permutations(target, confounds):\\n\\n raise NotImplementedError()\",\n \"def getNegativeSamples(target, dataset, K):\\n\\n indices = [None] * K\\n for k in range(K):\\n newidx = dataset.sampleTokenIdx()\\n while newidx == target:\\n newidx = dataset.sampleTokenIdx()\\n indices[k] = newidx\\n return indices\",\n \"def getNegativeSamples(target, dataset, K):\\n\\n indices = [None] * K\\n for k in xrange(K):\\n newidx = dataset.sampleTokenIdx()\\n while newidx == target:\\n newidx = dataset.sampleTokenIdx()\\n indices[k] = newidx\\n return indices\",\n \"def getNegativeSamples(target, dataset, K):\\n\\n indices = [None] * K\\n for k in xrange(K):\\n newidx = dataset.sampleTokenIdx()\\n while newidx == target:\\n newidx = dataset.sampleTokenIdx()\\n indices[k] = newidx\\n return indices\",\n \"def getNegativeSamples(target, dataset, K):\\n\\n indices = [None] * K\\n for k in xrange(K):\\n newidx = dataset.sampleTokenIdx()\\n while newidx == target:\\n newidx = dataset.sampleTokenIdx()\\n indices[k] = newidx\\n return indices\",\n \"def two_sum(target, ls):\\n complements = set()\\n for num in ls:\\n if num in complements:\\n return True\\n complements.add(target - num)\\n\\n return False\",\n \"def get_negatives(target, negatives, N, K=5):\\n res = np.random.choice(negatives, size=(N, K))\\n for i in range(len(res)):\\n for j in range(K):\\n if res[i, j] == target[i]:\\n res[i, j] = np.random.choice(negatives, size=1)\\n\\n return res\",\n \"def get_for_target(self, target):\\n return self.get_for_targets([target])\",\n \"def genSubset(L):\\n if len(L) == 0:\\n return [[]] # list of empty list\\n smaller = genSubset(L[:-1]) # the list without last element\\n extra = L[-1:] # a list of just the last element\\n new = []\\n for small in smaller:\\n new.append(small + extra)\\n return smaller + new\",\n \"def subsets(arr):\\n return chain(*[combinations(arr, i + 1) for i, a in enumerate(arr)])\",\n \"def subsets(arr):\\n return chain(*[combinations(arr, i + 1) for i, a in enumerate(arr)])\",\n \"def genSubset2(L):\\n import itertools\\n result = []\\n for i in range(len(L) + 1):\\n result += list(itertools.combinations(L, i))\\n return result\",\n \"def batch(source, target):\\r\\n indices = np.random.choice(range(source.shape[0]), size=BATCH_SIZE)\\r\\n source = np.take(source, indices, axis=0)\\r\\n target = np.take(target, indices, axis=0)\\r\\n return (source, target)\",\n \"def get_pool_subset(X_pool, Y_pool, subset_size=2000):\\n subset_indices = np.asarray(random.sample(range(0,X_pool.shape[0]), subset_size))\\n X_pool_subset = X_pool[subset_indices]\\n Y_pool_subset = Y_pool[subset_indices]\\n X_pool = np.delete(X_pool, subset_indices, axis=0)\\n Y_pool = np.delete(Y_pool, subset_indices, axis=0)\\n return (X_pool, Y_pool), (X_pool_subset, Y_pool_subset)\",\n \"def __get_min_indexes(num_list, number):\\n result = []\\n\\n num_list = np.array(num_list)\\n result = np.argpartition(num_list, number)[:number]\\n\\n return result\",\n \"def get_subset(self, start=None, end=None):\\n \\n if start is None and end is None:\\n return self.img_lst\\n elif start is None:\\n return self.img_lst[:end]\\n elif end is None:\\n return self.img_lst[start:]\\n else:\\n return self.img_lst[start:end]\",\n \"def get_relevant_indices(dataset, classes, target_classes):\\n indices = []\\n for i in range(len(dataset)):\\n # Check if the label is in the target classes\\n label_index = dataset[i][1] # ex: 3\\n label_class = classes[label_index] # ex: 'cat'\\n if label_class in target_classes:\\n indices.append(i)\\n return indices\",\n \"def bin_search(target, low, high, int_list): # must use recursion\\n if int_list == None:\\n raise ValueError\\n if high < low: # returns None if target is not found\\n return None\\n midpoint = (high + low) // 2\\n if int_list[midpoint] == target:\\n return midpoint\\n elif target < int_list[midpoint]: # when target is lower than midpoint\\n return bin_search(target, low, midpoint - 1, int_list)\\n elif target > int_list[midpoint]: # when target is greater than midpoint\\n return bin_search(target, midpoint + 1, high, int_list)\",\n \"def twoSum(self, nums, target):\\n for index_i, i in enumerate(nums):\\n for index_j, j in enumerate(nums[index_i+1:]):\\n if j + i == target:\\n return [index_i + 1, index_j + index_i + 2]\",\n \"def Collection_select_cheap(C:list, n: float)->list:\\r\\n result = []\\r\\n for rest in C:\\r\\n if Restaurant_is_cheap(rest, n) == True:\\r\\n result.append(rest)\\r\\n return result\",\n \"def _subset(lst: list, val_filter: str) -> int:\\n \\n for i, v in enumerate(lst):\\n if v == val_filter:\\n return i\",\n \"def get_for_targets(self, targets):\\n products = OrderedSet()\\n for target in targets:\\n products.update(self._products_by_target[target])\\n return products\",\n \"def twoSum(self, nums: List[int], target: int) -> List[int]:\\n diffRec = {}\\n for i, v in enumerate(nums):\\n if v in diffRec:\\n return [diffRec[v], i]\\n else:\\n diffRec[target - v] = i\\n return -1\",\n \"def bin_search(target, low, high, int_list): # must use recursion\\n if int_list == None:\\n raise ValueError\\n if len(int_list) == 0:\\n return None\\n middle = (low + high) // 2\\n if low > high or low < 0 or high > len(int_list):\\n return None\\n elif int_list[middle] == target:\\n return middle \\n elif int_list[middle] > target: \\n return bin_search(target, low, middle - 1, int_list)\\n else:\\n return bin_search(target, middle + 1, high, int_list)\",\n \"def selectRandomSubListFromListWithRepl(ldata, num):\\n\\treturn list(map(lambda i : selectRandomFromList(ldata), range(num)))\",\n \"def bin_search(target, low, high, int_list): # must use recursion\\n if int_list == None:\\n raise ValueError(\\\"Must be a list\\\")\\n \\n middle = (low + high) // 2\\n if low > high:\\n return None\\n if int_list[middle] > target:\\n return bin_search(target, low, middle - 1, int_list)\\n if int_list[middle] < target:\\n return bin_search(target, middle + 1, high, int_list)\\n return middle\",\n \"def find_index(vec_vals,target):\\n target=np.atleast_1d(target) #turn scalar into iterable, no op if already array\\n vec_vals=np.array(vec_vals)\\n index_list=[]\\n for item in target:\\n first_index=np.argmin(np.abs(vec_vals - item))\\n index_list.append(first_index)\\n return index_list\",\n \"def uniform_select(xs):\\n n = len(xs) - 1\\n i = randint(0, n)\\n return xs[i]\",\n \"def s(target: QubitSetInput) -> Iterable[Instruction]:\\n return [Instruction(S(), target=qubit) for qubit in QubitSet(target)]\",\n \"def random_choice_no_return(arr, num_lst):\\r\\n num_lst_arr = np.array(num_lst)\\r\\n num_sum = num_lst_arr.sum()\\r\\n if type(arr) == list:\\r\\n arr = np.array(arr)\\r\\n assert num_sum <= arr.size\\r\\n results = []\\r\\n arr_residue = np.arange(arr.size)\\r\\n for num in num_lst_arr:\\r\\n idx_chosen = np.random.choice(arr_residue.size, num, replace=False)\\r\\n chosen_idx_in_arr = np.sort(arr_residue[idx_chosen])\\r\\n results.append(arr[chosen_idx_in_arr])\\r\\n arr_residue = np.delete(arr_residue, idx_chosen)\\r\\n return results\",\n \"def filter_by_subset(self, *args):\\n self.subset_labels = sorted(set(self.subset_labels + list(args)))\\n return self\",\n \"def selections(xs):\\n for i, x in enumerate(xs):\\n yield (x, xs[:i] + xs[i + 1:])\",\n \"def minOperations(self, target: list[int], arr: list[int]) -> int:\\n orders = {x: i for i, x in enumerate(target)}\\n stack = []\\n for x in arr:\\n if x not in orders:\\n continue\\n\\n i = bisect_left(stack, orders[x])\\n if i == len(stack):\\n stack.append(0)\\n\\n stack[i] = orders[x]\\n\\n return len(target) - len(stack)\",\n \"def run(self, target: int) -> list:\\n\\n valid_values = range(0, 99)\\n\\n # This will be some sort of brute force attempt\\n values = [0, 0]\\n while values[0] < 100 and values[1] < 100:\\n self.reset()\\n# import pdb; pdb.set_trace()\\n test = self._process(values[0], values[1])\\n if test == target:\\n break\\n else:\\n if values[0] <= 99:\\n if values[1] < 99:\\n values[1] += 1\\n elif values[1] == 99 and values[0] < 99:\\n values[0] += 1\\n values[1] = 0\\n\\n else:\\n raise OpCodeError(\\\"No value possible\\\")\\n\\n return 100 * values[0] + values[1]\",\n \"def get_random_indexes(msk, n_idxs):\\n pos_idxs = np.array(np.where(msk > 0))\\n neg_idxs = np.array(np.where(msk == 0))\\n n_pos = pos_idxs.shape[1] # number of positives found in the mask\\n n_neg = neg_idxs.shape[1] # number of negatives found in the mask\\n n_min = min(n_neg, min(n_idxs, n_pos))\\n rnd_idxs_pos = range(n_pos)\\n np.random.shuffle(rnd_idxs_pos)\\n rnd_idxs_neg = range(n_neg)\\n np.random.shuffle(rnd_idxs_neg)\\n return pos_idxs[:, rnd_idxs_pos[:n_min]], neg_idxs[:, rnd_idxs_neg[:n_min]]\",\n \"def t(target: QubitSetInput) -> Iterable[Instruction]:\\n return [Instruction(T(), target=qubit) for qubit in QubitSet(target)]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7094783","0.65067834","0.6460729","0.63038445","0.6270336","0.62450624","0.62270397","0.61682236","0.61059326","0.6029637","0.6015087","0.5967162","0.5875812","0.5808211","0.5807387","0.57974637","0.5757506","0.5754575","0.5735689","0.5707086","0.5698021","0.5663836","0.5663737","0.5657806","0.563444","0.56282127","0.56242454","0.5615647","0.56149155","0.5608319","0.5607154","0.55636203","0.5543996","0.55210614","0.55155677","0.55149686","0.55004233","0.5490599","0.5488292","0.54541045","0.5453218","0.5440277","0.5430237","0.5413987","0.5412333","0.54090625","0.5388732","0.5387578","0.53784823","0.5366981","0.5362764","0.5351884","0.5347255","0.5342287","0.5338063","0.5330721","0.53238887","0.5320647","0.5317047","0.53103375","0.53091466","0.530898","0.5302149","0.5301065","0.53002304","0.5292476","0.5289203","0.5289203","0.5289203","0.5288344","0.5281057","0.52779955","0.52768844","0.52747446","0.52747446","0.5273816","0.5273682","0.5270671","0.5269305","0.5263276","0.52620447","0.5259994","0.52497137","0.52462524","0.5243741","0.522911","0.5226946","0.5226933","0.5225722","0.52130455","0.52084816","0.520359","0.5191146","0.5187646","0.51846623","0.5178681","0.517726","0.51626337","0.5155919","0.5155368"],"string":"[\n \"0.7094783\",\n \"0.65067834\",\n \"0.6460729\",\n \"0.63038445\",\n \"0.6270336\",\n \"0.62450624\",\n \"0.62270397\",\n \"0.61682236\",\n \"0.61059326\",\n \"0.6029637\",\n \"0.6015087\",\n \"0.5967162\",\n \"0.5875812\",\n \"0.5808211\",\n \"0.5807387\",\n \"0.57974637\",\n \"0.5757506\",\n \"0.5754575\",\n \"0.5735689\",\n \"0.5707086\",\n \"0.5698021\",\n \"0.5663836\",\n \"0.5663737\",\n \"0.5657806\",\n \"0.563444\",\n \"0.56282127\",\n \"0.56242454\",\n \"0.5615647\",\n \"0.56149155\",\n \"0.5608319\",\n \"0.5607154\",\n \"0.55636203\",\n \"0.5543996\",\n \"0.55210614\",\n \"0.55155677\",\n \"0.55149686\",\n \"0.55004233\",\n \"0.5490599\",\n \"0.5488292\",\n \"0.54541045\",\n \"0.5453218\",\n \"0.5440277\",\n \"0.5430237\",\n \"0.5413987\",\n \"0.5412333\",\n \"0.54090625\",\n \"0.5388732\",\n \"0.5387578\",\n \"0.53784823\",\n \"0.5366981\",\n \"0.5362764\",\n \"0.5351884\",\n \"0.5347255\",\n \"0.5342287\",\n \"0.5338063\",\n \"0.5330721\",\n \"0.53238887\",\n \"0.5320647\",\n \"0.5317047\",\n \"0.53103375\",\n \"0.53091466\",\n \"0.530898\",\n \"0.5302149\",\n \"0.5301065\",\n \"0.53002304\",\n \"0.5292476\",\n \"0.5289203\",\n \"0.5289203\",\n \"0.5289203\",\n \"0.5288344\",\n \"0.5281057\",\n \"0.52779955\",\n \"0.52768844\",\n \"0.52747446\",\n \"0.52747446\",\n \"0.5273816\",\n \"0.5273682\",\n \"0.5270671\",\n \"0.5269305\",\n \"0.5263276\",\n \"0.52620447\",\n \"0.5259994\",\n \"0.52497137\",\n \"0.52462524\",\n \"0.5243741\",\n \"0.522911\",\n \"0.5226946\",\n \"0.5226933\",\n \"0.5225722\",\n \"0.52130455\",\n \"0.52084816\",\n \"0.520359\",\n \"0.5191146\",\n \"0.5187646\",\n \"0.51846623\",\n \"0.5178681\",\n \"0.517726\",\n \"0.51626337\",\n \"0.5155919\",\n \"0.5155368\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.693455"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14866,"cells":{"query":{"kind":"string","value":"Here select interesting offers to notify in tg in where defined additional filters, for example, distance from center less than 30 km and defined period for which offers were created"},"document":{"kind":"string","value":"async def extract_data_to_notify(app):\n notification_data = await app.db.select(\n f\"\"\"\n SELECT added_timestamp,\n total_area,\n full_url, \n jk_url,\n nearest_underground, \n nearest_underground_dist, \n price_rur, \n rooms_count,\n is_apartments\n FROM public.flats\n WHERE 1=1 \n AND created_at > (now() - interval '1 hours' - interval '1 minute')\n -- AND distance_from_center <= 9\n \"\"\", {}\n )\n return notification_data"},"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 _compute_offers_to_send(self) -> Dict[Tuple[float, float], float]:\n partial_asgt = self._neighbors_values.copy()\n offers = dict()\n\n for limited_asgt in generate_assignment_as_dict([self.variable, self._partner]):\n partial_asgt.update(limited_asgt)\n cost = self._compute_cost(**partial_asgt)\n if self.logger.isEnabledFor(logging.DEBUG):\n self.logger.debug(\n f\"looking for offer : {partial_asgt} - cost {cost}\"\n f\" current {self.current_cost} {self._mode}\"\n )\n\n if (self.current_cost > cost and self._mode == \"min\") or (\n self.current_cost < cost and self._mode == \"max\"\n ):\n offers[(limited_asgt[self.name], limited_asgt[self._partner.name])] = (\n self.current_cost - cost\n )\n return offers","def filterEvents(intervals_dates,list_infected,distance):\n d=distance\n list_gpsevents=[]\n for z in range(len(intervals_dates)-1):\n print(\"Interval: \",intervals_dates[z], \"y\", intervals_dates[z+1])\n infected,uninfected=getTrazaTimestamp(intervals_dates[z],intervals_dates[z+1],GPSrecords,list_infected)\n events_gps = nearest_neighbor(infected, uninfected, d)\n events_gps = events_gps.drop(['geometry','closest_stop_geom'], axis=1)\n print(len(events_gps))\n if(len(events_gps)!=0):\n list_gpsevents.append(events_gps.reset_index(drop=True))\n else:\n events_gps=pd.DataFrame()\n list_gpsevents.append(events_gps)\n #GPSevents=pd.concat(list_gpsevents).reset_index(drop=True)\n #return GPSevents\n return list_gpsevents","def adjust_filter(self, queryset):\n new_queryset = queryset.filter(points__gt=0.0).order_by('-points', 'rate')\n return self.validate_queryset(new_queryset)","def prepare_filter_params(context, plan_name=None, **kw):\n from debra.models import Influencer\n from debra import logical_categories\n from django.core.cache import get_cache\n cache = get_cache('memcached')\n params = None #cache.get('filter_params')\n if not params:\n # influencers = Influencer.objects.filter(\n # show_on_search=True).exclude(blacklisted=True)\n # influencers = influencers.filter(\n # score_popularity_overall__isnull=False)\n # influencers = influencers.distinct()\n popularity = [\n {\n \"title\": \"Small\",\n },\n {\n \"title\": \"Medium\",\n },\n {\n \"title\": \"Large\",\n }\n ]\n engagement = [\n {\n \"title\": \"0-20\",\n },\n {\n \"title\": \"21-40\",\n },\n {\n \"title\": \"41-60\",\n },\n {\n \"title\": \"61-80\",\n },\n {\n \"title\": \"81+\",\n },\n ]\n\n price_ranges = [\n {\n \"title\": \"Cheap\",\n \"text\": \"Primarily In-expensive\"\n },\n # {\n # \"title\": \"Mid-level\",\n # },\n { \n \"title\": \"Expensive\",\n \"text\": \"Primarily High-end\"\n }\n ]\n\n genders = [\n {\n \"title\": \"Female\",\n },\n {\n \"title\": \"Male\",\n },\n ]\n\n social = [\n {\n \"value\": \"Facebook\",\n \"icon\": \"icon-social_facebook\"\n },\n {\n \"value\": \"Pinterest\",\n \"icon\": \"icon-social_pinterest2\"\n },\n {\n \"value\": \"Twitter\",\n \"icon\": \"icon-social_twitter\"\n },\n {\n \"value\": \"Instagram\",\n \"icon\": \"icon-social_instagram2\"\n },\n {\n \"value\": \"Youtube\",\n \"icon\": \"icon-social_youtube\"\n },\n ]\n\n age_groups = [\n {\n \"value\": \"0_19\",\n \"icon\": \"0 - 19\"\n },\n {\n \"value\": \"20_24\",\n \"icon\": \"20 - 24\"\n },\n {\n \"value\": \"25_29\",\n \"icon\": \"25 - 29\"\n },\n {\n \"value\": \"30_34\",\n \"icon\": \"30 - 34\"\n },\n {\n \"value\": \"35_39\",\n \"icon\": \"35 - 39\"\n },\n {\n \"value\": \"40\",\n \"icon\": \"40+\",\n }\n ]\n\n activity = [{\"value\": \"Blog\", \"icon\": \"icon icon-letter_quotes2\"}] + social\n\n categories = []\n\n brands = []\n\n locations = redis_cache.get('toplocs') or []\n # locations = Influencer.get_locations_list(num_results=200)\n # locations = Influencer.get_locations_list(num_results=None)\n\n tags = kw.get('tags', [])\n\n source = [{\"title\": \"Signup\", \"value\": \"blogger_signup\"}]\n\n params = {\n 'show_filters': True,\n 'popularity': list(popularity),\n 'engagement': list(engagement),\n 'categories': list(categories),\n 'brands': list(brands),\n 'priceranges': list(price_ranges),\n 'locations': list(locations),\n 'genders': list(genders),\n 'social': list(social),\n 'activity': list(activity),\n 'tags': list(tags),\n 'source': list(source),\n 'age_groups': list(age_groups),\n 'enabled_filters': [\n \"popularity\", \"engagement\", \"categories\", \"brands\",\n \"priceranges\", \"location\", \"genders\", \"socials\", \"activity\",\n \"tags\", \"likes\", \"shares\", \"comments\", \"source\", \"avgAge\",\n \"customCategories\", \"customOccupation\", \"customSex\", \"customEthnicity\",\n \"customTags\", \"customLanguage\", \"customAgeRange\",]\n }\n cache.set('filter_params', params)\n\n for loc in params.get('locations', []):\n loc['value'] = loc['title']\n\n if True: #settings.DEBUG:\n params['categories'] = [{\"title\": \"Fashion\", \"category\": \"fashion\"},\n {\"title\": \"Food\", \"category\": \"food\"},\n {\"title\": \"Kids\", \"category\": \"kids\"},\n {\"title\": \"Beauty\", \"category\": \"beauty\"},\n {\"title\": \"Travel\", \"category\": \"travel\"}]\n else:\n params['categories'] = []\n \n return params","def get_timeline_filters(self, req):","def queryGenerator(itemset,venue,min_runs):\n level=len(itemset)\n partners=[[] for k in range(level)]\n for j in range(level):\n for i in range(level):\n partners[i].append({'partner'+str(j+1):itemset[i]})\n k=itemset.pop(0)\n itemset.append(k)\n ors=[]\n for cond in partners:\n ors.append({'$and':cond})\n \n match={}\n match['$or']=ors\n match['total_runs']={'$gte':30}\n if venue:\n match['venue']=venue\n\n return match","def filter_metrics_choices(self): \n cols = pd.Series(tdr.get_catalog().tubidw.all_metric_hourly.columns)\n filter_metrics = ['no filters'] + cols[cols.str.endswith(tuple(['_count', '_sec']))].tolist()\n return filter_metrics","def create_in_range_lst(source_features: list, user_zip_code: str, radius: int,\n active_set: set, second_dose: bool,\n provider_filter: list) -> list:\n in_range_locs = []\n user_coords = ZIP_MAP_DICT[user_zip_code][0]\n for loc in source_features:\n if loc['properties']['appointments_available'] and\\\n loc['properties']['provider_brand'].lower() in active_set and\\\n (loc['properties']['appointments_available_all_doses'] is True or\n loc['properties']['appointments_available_2nd_dose_only'] is\n second_dose) and \\\n (len(provider_filter) == 0 or\n loc['properties']['provider_brand_name'] in provider_filter):\n # format [latitude, longitude]\n loc_coord = loc['geometry']['coordinates'][::-1]\n if loc_coord != [None, None]:\n if earth_distance(loc_coord[0], loc_coord[1],\n user_coords[0], user_coords[1]) <= radius:\n in_range_locs.append(loc)\n return in_range_locs","def filter(self, filters):","def filter_data(self,tod,sel,medfilt_size):\n \n filters = np.zeros((tod.shape[0],tod.shape[1],tod.shape[2],int(np.sum(sel))))\n for ifeed in tqdm(self.feedlist,desc=f'{self.name}:filters:{self.source}'):\n feed_tod = tod[ifeed,...] \n for isb in range(tod.shape[1]):\n for ichan in range(tod.shape[2]):\n z = feed_tod[isb,ichan,sel]\n bad = np.where(np.isnan(z))[0]\n if len(bad) == len(z):\n continue\n if len(bad) > 0:\n good = np.where(np.isfinite(z))[0]\n \n nearest = [good[np.argmin(np.abs(good-b))] for b in bad]\n z[bad] = z[nearest]\n filters[ifeed,isb,ichan,:] = median_filter(z,medfilt_size)\n \n return filters","def filter_viable_offers(want, have, offers) -> List:\n return [x for x in offers if is_offer_viable(want, have, x) is True]","def filter_potential_deal_table(apply_n_clicks, potential_deal_table_data,\n selected_year, selected_make, selected_model, min_odometer,\n max_odometer, min_price, max_price, min_offer_price,\n max_offer_price):\n potential_deal_db_data = DBApi.get_instance().potential_records\n filtered_year_ids = []\n filtered_make_ids = []\n filtered_model_ids = []\n filtered_min_odometer_ids = []\n filtered_max_odometer_ids = []\n filtered_min_price_ids = []\n filtered_max_price_ids = []\n filtered_min_offer_price_ids = []\n filtered_max_offer_price_ids = []\n\n if selected_year or selected_make or min_odometer or max_odometer or min_price or \\\n max_price or min_offer_price or max_offer_price:\n # Odometer filter\n if min_odometer and max_odometer:\n if int(max_odometer) < int(min_odometer):\n return [\n potential_deal_table_data,\n \"Max odometer value should be greater than min odometer value\",\n True,\n 5000\n ]\n if min_price and max_price:\n if int(max_price) < int(min_price):\n return [\n potential_deal_table_data,\n \"Max price value should be greater than min price value\",\n True,\n 5000\n ]\n\n if min_offer_price and max_offer_price:\n if int(max_offer_price) < int(min_offer_price):\n return [\n potential_deal_table_data,\n \"Max offer price MMR value should be greater \"\n \"than min offer price MMR value\",\n True,\n 5000\n ]\n\n for data in potential_deal_db_data:\n # Year filter\n if selected_year:\n for year in selected_year:\n if year in data[\"make_model_year\"]:\n filtered_year_ids.append(data[\"PotentialDealID\"])\n break\n else:\n filtered_year_ids.append(data[\"PotentialDealID\"])\n\n # Make filter\n if selected_make:\n for make in selected_make:\n if make in data[\"make_model_year\"].lower():\n filtered_make_ids.append(data[\"PotentialDealID\"])\n else:\n filtered_make_ids.append(data[\"PotentialDealID\"])\n\n # Model filter\n if selected_model:\n for model in selected_model:\n if model in data[\"make_model_year\"].lower():\n filtered_model_ids.append(data[\"PotentialDealID\"])\n else:\n filtered_model_ids.append(data[\"PotentialDealID\"])\n\n # Min odometer filter\n if min_odometer:\n if int(data[\"odometer\"]) >= int(min_odometer):\n filtered_min_odometer_ids.append(data[\"PotentialDealID\"])\n else:\n filtered_min_odometer_ids.append(data[\"PotentialDealID\"])\n\n # Max odometer filter\n if max_odometer:\n if int(data[\"odometer\"]) <= int(max_odometer):\n filtered_max_odometer_ids.append(data[\"PotentialDealID\"])\n else:\n filtered_max_odometer_ids.append(data[\"PotentialDealID\"])\n\n # Min price filter\n if min_price:\n if int(data[\"price\"]) >= int(min_price):\n filtered_min_price_ids.append(data[\"PotentialDealID\"])\n else:\n filtered_min_price_ids.append(data[\"PotentialDealID\"])\n\n # Max price filter\n if max_price:\n if int(data[\"price\"]) <= int(max_price):\n filtered_max_price_ids.append(data[\"PotentialDealID\"])\n else:\n filtered_max_price_ids.append(data[\"PotentialDealID\"])\n\n # Min offer price filter\n if min_offer_price:\n if int(data[\"OfferPricePctMMR\"]) >= int(min_offer_price):\n filtered_min_offer_price_ids.append(data[\"PotentialDealID\"])\n else:\n filtered_min_offer_price_ids.append(data[\"PotentialDealID\"])\n\n # Max offer price filter\n if max_offer_price:\n if int(data[\"OfferPricePctMMR\"]) <= int(max_offer_price):\n filtered_max_offer_price_ids.append(data[\"PotentialDealID\"])\n else:\n filtered_max_offer_price_ids.append(data[\"PotentialDealID\"])\n\n filtered_ids = set(filtered_year_ids).intersection(\n set(filtered_make_ids),\n set(filtered_model_ids),\n set(filtered_min_odometer_ids),\n set(filtered_max_odometer_ids),\n set(filtered_min_price_ids),\n set(filtered_max_price_ids),\n set(filtered_min_offer_price_ids),\n set(filtered_max_offer_price_ids)\n )\n filtered_data = [\n data\n for data in potential_deal_db_data\n if data[\"PotentialDealID\"] in filtered_ids\n ]\n return [filtered_data, \"\", False, 2000]\n return [potential_deal_db_data, \"\", False, 2000]","def extract_tt_by_periods(ttri, periods, start_time, end_time, filters):\n logger = getLogger(__name__)\n # sess = conn.get_session()\n das = {}\n all_wz_features = {}\n all_wz_laneconfigs = {}\n\n # collecting daily data\n for prd in periods:\n logger.debug('>>>> retrieving data for %s' % prd.get_date_string())\n year = prd.start_date.year\n sdate = prd.start_date\n edate = prd.end_date\n if year not in das:\n da_tt = tt.TravelTimeDataAccess(year)\n da_tt_wz = tt_workzone.TTWorkZoneDataAccess(year)\n da_tt_wz_feature = wz_feature.WZFeatureDataAccess()\n da_tt_wz_lncfg = wz_laneconfig.WZLaneConfigDataAccess()\n da_tt_weather = tt_weather.TTWeatherDataAccess(year)\n da_tt_snowmgmt = tt_snowmgmt.TTSnowManagementDataAccess(year)\n da_tt_incident = tt_incident.TTIncidentDataAccess(year)\n da_tt_specialevent = tt_specialevent.TTSpecialeventDataAccess(year)\n das[year] = (\n da_tt, da_tt_wz, da_tt_wz_feature, da_tt_wz_lncfg, da_tt_weather, da_tt_snowmgmt, da_tt_incident,\n da_tt_specialevent)\n\n (da_tt, da_tt_wz, da_tt_wz_feature, da_tt_wz_lncfg, da_tt_weather, da_tt_snowmgmt, da_tt_incident,\n da_tt_specialevent) = das[year]\n\n # traveltimes = da_tt.list_by_period(ttri.id, self.prd)\n weathers = da_tt_weather.list(ttri.id, sdate, edate, as_model=True)\n \"\"\":type: list[pyticas_tetres.ttrms_types.WeatherInfo] \"\"\"\n workzones = da_tt_wz.list(ttri.id, sdate, edate, as_model=True)\n \"\"\":type: list[pyticas_tetres.ttrms_types.WorkZoneInfo] \"\"\"\n incidents = da_tt_incident.list(ttri.id, sdate, edate, as_model=True)\n \"\"\":type: list[pyticas_tetres.ttrms_types.IncidentInfo] \"\"\"\n snowmgmts = da_tt_snowmgmt.list(ttri.id, sdate, edate, as_model=True)\n \"\"\":type: list[pyticas_tetres.ttrms_types.SnowManagementInfo] \"\"\"\n specialevents = da_tt_specialevent.list(ttri.id, sdate, edate, as_model=True)\n \"\"\":type: list[pyticas_tetres.ttrms_types.SpecialEventInfo] \"\"\"\n traveltimes = da_tt.list_by_period(ttri.id, prd)\n \"\"\":type: list[pyticas_tetres.ttrms_types.TravelTimeInfo] \"\"\"\n\n if not any(weathers):\n logger.debug('>>>> end of retrieving data for %s (no weather data)' % prd.get_date_string())\n continue\n\n extras = {\n 'weathers': {_tt.id: [] for _tt in traveltimes},\n 'workzones': {_tt.id: [] for _tt in traveltimes},\n 'incidents': {_tt.id: [] for _tt in traveltimes},\n 'specialevents': {_tt.id: [] for _tt in traveltimes},\n 'snowmgmts': {_tt.id: [] for _tt in traveltimes},\n }\n \"\"\":type: dict[str, dict[int, list]]\"\"\"\n\n _put_to_bucket(ttri, weathers, extras['weathers'], da_tt_weather, year, all_wz_features, all_wz_laneconfigs, das)\n _put_to_bucket(ttri, workzones, extras['workzones'], da_tt_wz, year, all_wz_features, all_wz_laneconfigs, das)\n _put_to_bucket(ttri, incidents, extras['incidents'], da_tt_incident, year, all_wz_features, all_wz_laneconfigs, das)\n _put_to_bucket(ttri, snowmgmts, extras['snowmgmts'], da_tt_snowmgmt, year, all_wz_features, all_wz_laneconfigs, das)\n _put_to_bucket(ttri, specialevents, extras['specialevents'], da_tt_specialevent, year, all_wz_features, all_wz_laneconfigs, das)\n\n for tti in traveltimes:\n _tt_weathers = extras['weathers'][tti.id]\n extdata = ExtData(tti,\n _tt_weathers[0] if _tt_weathers else None,\n extras['incidents'][tti.id],\n extras['workzones'][tti.id],\n extras['specialevents'][tti.id],\n extras['snowmgmts'][tti.id])\n\n if start_time <= tti.str2datetime(tti.time).time() <= end_time:\n for ef in filters:\n try:\n ef.check(extdata)\n except Exception as ex:\n tb.traceback(ex)\n logger.debug('>>>> end of retrieving data for %s (error occured 1)' % prd.get_date_string())\n continue\n else:\n for ef in filters:\n try:\n ef.check_outofrange(extdata)\n except Exception as ex:\n tb.traceback(ex)\n logger.debug('>>>> end of retrieving data for %s (error occured 2)' % prd.get_date_string())\n continue\n\n del extras\n logger.debug('>>>> end of retrieving data for %s' % prd.get_date_string())\n\n # sess.close()","def _apply_filters(self, df):\n df = df[(df['Date'] >= self.start_date) &\n (df['Date'] <= self.end_date)]\n return df","def Filter(self, info):\n\n add_item = True\n \n if add_item and (self.use_only_ids != None) and (uid not in self.use_only_ids):\n add_item = False\n \n if add_item and (info['latlong'] == None):\n add_item = False\n \n if add_item and (self.size != None) and (info['size'] < self.size):\n add_item = False\n \n if add_item and (self.expert_rank != None) and (info['expert_rank'] < self.expert_rank):\n add_item = False\n \n if add_item and (self.kosher != None) and (self.kosher == True and info['kosher'] == False):\n add_item = False\n \n if add_item and (self.visiting_center != None) and (self.visiting_center == True and info['visiting_center'] == False):\n add_item = False\n \n if add_item and (self.visiting_center_free_admission != None) and (self.visiting_center_free_admission == True and info['visiting_center_free_admission'] == False):\n add_item = False\n \n if add_item and self.visit_time != None:\n day_of_visit = time.strftime(\"%A\", time.localtime(self.visit_time)).lower()\n if info['hours'][day_of_visit] != None:\n closing_at_that_day = time.mktime(time.strptime(time.strftime(\"%A, %d %b %Y\", time.localtime(self.visit_time)) + \" %d:00:00\" % (info['hours'][day_of_visit]), \"%A, %d %b %Y %H:%M:%S\"))\n if self.visit_time > (closing_at_that_day - self._delta_time_before_close):\n add_item = False\n if day_of_visit == 'saturday' and self.kosher == True:\n add_item = False\n \n if add_item and self.use_weather: \n if not self.weather_client.GoodForWinery(self.weather_client.GetCondition(info['latlong'])):\n add_item = False\n \n return add_item","def get_entities_since_ts(self, query_field_name, timestamp, optional_filters, refresh_authentication=False):\n query = { }\n\n if query_field_name:\n query[query_field_name] = readable_datetime(timestamp) # utc datetime format\n\n # add any additional query parameters\n groups_filter = []\n impact_filter = None\n if optional_filters:\n # groups and relevance are managed after the api call is made\n if \"groups\" in optional_filters:\n groups_filter = optional_filters.pop('groups')\n if \"impact\" in optional_filters:\n impact_filter = int(optional_filters.pop('impact'))\n\n for k,v in optional_filters.items():\n query[k] = v\n\n LOG.debug(query)\n response, err_msg = self.api_call(\"GET\", 'alerts', query, refresh_authentication=refresh_authentication)\n\n results = response if isinstance(response, dict) else response.json()\n\n # trim results by optional filters\n if not err_msg and (groups_filter or impact_filter):\n filtered_results = []\n for alert in results['result']:\n accept_filtered = False\n # both groups_filter and impact_filter need to succeed if both are specified\n if groups_filter:\n # get the endpoint groups and test if list and filters intersect\n endpoint_groups = [group['name'] for group in alert.get(\"endpoint\", {}).get(\"groups\", [])]\n if list(set(groups_filter) & set(endpoint_groups)):\n accept_filtered = True\n\n if impact_filter:\n accept_filtered = bool(alert.get(\"impact\") >= impact_filter)\n\n if accept_filtered:\n filtered_results.append(alert)\n\n LOG.info(\"Original List: %s. Filtered List: %s\", len(results), len(filtered_results))\n results = { \"result\": filtered_results }\n\n return results, err_msg","def filtercmd(client, args):\n try:\n phrases = [list(group) for k, group in groupby(args, lambda x: x == \"OR\") if not k]\n for phrase in phrases:\n # we do before/after by id not by timestamp\n if phrase[0] in ('before', 'b4', 'after', 'af') and len(phrase) > 1:\n r = client.req_by_id(phrase[1], headers_only=True)\n phrase[1] = str(time_to_nsecs(r.time_start))\n client.context.apply_phrase(phrases)\n except InvalidQuery as e:\n print(e)","def get_active_filter():\n return (Q(start_date__gte=timezone.now()) |\n Q(end_date__gte=timezone.now()))","def queryset(self, request, queryset):\n if self.value() == 'p':\n return queryset.filter(pointe=True)\n if self.value() == 'rapp':\n return queryset.filter(rapp__isnull=False)\n if self.value() == 'rien':\n return queryset.filter(rapp__isnull=True, pointe=False)\n if self.value() == 'pr':\n # comme il y a trois position, si l'on exclue les ni rapproche ni pointe on a les rapproche ou pointe\n return queryset.exclude(rapp__isnull=True, pointe=False)\n if self.value() == 'nrapp':\n return queryset.filter(rapp__isnull=True)","def queryset(self, request, queryset):\n if self.value() == 'examine':\n return queryset.filter(ignored_at=None, address_1__isnull=False, longitude_position=None).exclude(address_1='')\n if self.value() == 'done':\n return queryset.filter(longitude_position__isnull=False)\n if self.value() == 'ignore':\n return queryset.filter(ignored_at__isnull=False)","def filter_tod(data,feedtod,ifeed,level2='level2'):\n nBands, nChans,nSamples = feedtod.shape\n\n mask = np.zeros(nSamples,dtype=bool)\n\n medfilt_coefficient = data[f'{level2}/Statistics/filter_coefficients'][ifeed,...]\n atmos = data[f'{level2}/Statistics/atmos'][ifeed,...]\n atmos_coefficient = data[f'{level2}/Statistics/atmos_coefficients'][ifeed,...]\n scan_edges = data[f'{level2}/Statistics/scan_edges'][...]\n\n az = data['level1/spectrometer/pixel_pointing/pixel_az'][ifeed,:]\n el = data['level1/spectrometer/pixel_pointing/pixel_el'][ifeed,:]\n for iscan,(start,end) in enumerate(scan_edges):\n median_filter = data[f'{level2}/Statistics/FilterTod_Scan{iscan:02d}'][ifeed,...]\n mask[start:end] = True\n N = int((end-start))\n for iband in range(nBands):\n for ichan in range(nChans):\n\n mdl = Statistics.AtmosGroundModel(atmos[iband,iscan],az[start:end],el[start:end]) *\\\n atmos_coefficient[iband,ichan,iscan,0]\n mdl += median_filter[iband,:N] * medfilt_coefficient[iband,ichan,iscan,0]\n feedtod[iband,ichan,start:end] -= mdl\n feedtod[iband,ichan,start:end] -= np.nanmedian(feedtod[iband,ichan,start:end])\n\n return feedtod, mask","def get_timeline_events(self, req, start, stop, filters):","def get_filters():\n \n \"\"\"\"\"\"\"\"\n \n \"\"\"Messeges to genrate filters\"\"\"\n\tnote_messege = 'In this project, we make use of Python to explore data related to bike share systems for three major cities in the United States\\n'\n welcome_messege = 'Hello! Let\\'s explore some US bikeshare data!\\n'\n enter_city_name_messege = 'Which city would you like to filter by? Chicago, New York City or Washington? '\n filter_definition_messege = '\\nWould you like to filter the data by - \\n1. Month\\n2. Day\\n3. Both\\n4. No Filter\\n\\nPlease choose the appropriate filter name.\\nNote: Incorrect filter name will result as \\'no filter selected\\' by the user.\\n'\n enter_filter_messege = 'Desired filter (e.g: Month, Day, Both or No Filter): '\n enter_month_name_messege = 'Enter month name (e.g: january, february, march, april, may or june): '\n enter_day_name_messege = 'Enter day of the week (e.g: monday, tuesday, wednesday, thursday, friday, saturday, sunday): '\n exception_messege = '\\nWarning! That is not a valid input.\\n'\n warning_city_name_messege = '\\nWarning! Invalid city name. Select city name from the following cities only - Chicago, New York City or Washington.' \n warning_month_name_messege = '\\nWarning! Invalid month name. Select month name from the following months only - january, february, march, april, may or june'\n warning_day_name_messege = '\\nWarning! Invalid day name. Select day name from the following days only - monday, tuesday, wednesday, thursday, friday, saturday, sunday'\n \"\"\"\"\"\"\"\"\n \n \"\"\"City, Month and Day List\"\"\"\n city_list = ['chicago', 'new york city', 'washington']\n month_list = ['january', 'february', 'march', 'april', 'may', 'june']\n day_list = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']\n \"\"\"\"\"\"\"\"\n \n\tprint(note_messege)\n print(welcome_messege)\n \n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs \n while True:\n try:\n city = input(enter_city_name_messege)\n break\n except:\n print(exception_messege)\n \n while city.lower() not in city_list:\n while True:\n try: \n print(warning_city_name_messege)\n city = input(enter_city_name_messege)\n break\n except:\n print(exception_messege)\n \n print(filter_definition_messege)\n while True:\n try:\n filter_choice = input(enter_filter_messege)\n break\n except:\n print(exception_messege)\n while True: \n if filter_choice.lower() == 'month':\n # TO DO: get user input for month (all, january, february, ... , june)\n while True:\n try:\n month = input(enter_month_name_messege) \n break\n except:\n print(exception_messege)\n while month.lower() not in month_list:\n while True:\n try: \n print(warning_month_name_messege)\n month = input(enter_month_name_messege) \n break\n except:\n print(exception_messege)\n day = 'all'\n break\n \n elif filter_choice.lower() == 'day':\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday) \n while True:\n try:\n day = input(enter_day_name_messege)\n break\n except:\n print(exception_messege)\n while day.lower() not in day_list:\n while True:\n try: \n print(warning_day_name_messege)\n day = input(enter_day_name_messege) \n break\n except:\n print(exception_messege)\n month = 'all'\n break\n \n elif filter_choice.lower() == 'both':\n # TO DO: get user input for month (all, january, february, ... , june)\n while True:\n try:\n month = input(enter_month_name_messege)\n break\n except:\n print(exception_messege)\n while month.lower() not in month_list:\n while True:\n try: \n print(warning_month_name_messege)\n month = input(enter_month_name_messege) \n break\n except:\n print(exception_messege)\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\n while True:\n try:\n day = input(enter_day_name_messege)\n break\n except:\n print(exception_messege)\n while day.lower() not in day_list:\n while True:\n try: \n print(warning_day_name_messege)\n day = input(enter_day_name_messege) \n break\n except:\n print(exception_messege)\n break\n \n else:\n month = 'all'\n day = 'all'\n break\n \n\n print('-'*40)\n return city.lower(), month.lower(), day.lower()","def test_nearest_filter(self):\n for airport, reports, count in (\n (True, True, 6),\n (True, False, 16),\n (False, True, 6),\n (False, False, 30),\n ):\n stations = station.nearest(30, -80, 30, airport, reports, 1.5)\n self.assertEqual(len(stations), count)","def track_request(params):\n\n if len(params) == 0:\n number_of_orders = \"10\"\n field = None\n from_date = None\n condition_1 = None\n to_date = None\n condition_2 = None\n status = None\n value = None\n condition_3 = None\n else:\n number_of_orders = params['number_of_orders'] if len(params['number_of_orders']) != 0 else \"20\"\n field = \"created_at\"\n from_date = params['from_date'] + \" 00:00:00\" if len(params['from_date']) != 0 else \"2000-01-01 00:00:00\" \n condition_1 = \"gteq\"\n to_date = params['to_date'] + \" 23:59:59\" if len(params['to_date']) != 0 else \"2100-12-31 23:59:59\"\n condition_2 = \"lteq\"\n status = None if params['status'] == \"None\" else \"status\"\n value = None if params['status'] == \"None\" else params['status']\n condition_3 = None if params['status'] == \"None\" else \"eq\"\n\n generate_request = oAuth_magento()\n\n payload = { \"searchCriteria[filter_groups][0][filters][0][field]\": field,\n \"searchCriteria[filter_groups][0][filters][0][value]\": from_date,\n \"searchCriteria[filter_groups][0][filters][0][condition_type]\": condition_1,\n\n \"searchCriteria[filter_groups][1][filters][0][field]\": field,\n \"searchCriteria[filter_groups][1][filters][0][value]\": to_date,\n \"searchCriteria[filter_groups][1][filters][0][condition_type]\": condition_2,\n\n \"searchCriteria[filter_groups][2][filters][0][field]\": status,\n \"searchCriteria[filter_groups][2][filters][0][value]\": value,\n \"searchCriteria[filter_groups][2][filters][0][condition_type]\": condition_3,\n \n \"searchCriteria[pageSize]\": number_of_orders,\n \"searchCriteria[sortOrders][0][field]\":\"created_at\",\n \"fields\": \"items[increment_id,base_currency_code,grand_total,created_at,status,billing_address[company,firstname,lastname]]\",\n }\n\n response = requests.request(\"GET\", url=generate_request[0], headers=generate_request[1], params=payload)\n # with open('temp_files/magento_orders_test.json','w') as f:\n # f.write(response.text)\n json_response = json.loads(response.text)\n for ele in json_response['items']:\n for key, val in ele.items():\n if key == 'billing_address':\n name_container = ele.pop(key)\n try:\n ele['purchasing_institute'] = name_container['company']\n except:\n ele['purchasing_institute'] = name_container['firstname'] + ' ' + name_container['lastname']\n else:\n pass\n col_headers = list((json_response['items'][0]).keys())\n return json_response['items'], col_headers","def get_rides(cls, **kwargs):\n\n\n q = cls.query.options(db.joinedload('user'))\n\n if kwargs.get('start_lat'):\n deg = float(kwargs.get('deg'))\n start_lat = float(kwargs.get('start_lat'))\n start_lng = float(kwargs.get('start_lng'))\n\n q = q.filter(\n ( (cls.start_lat < str(start_lat + deg)) &\n (cls.start_lat > str(start_lat - deg))\n ) &\n ( (cls.start_lng < str(start_lng + deg)) &\n (cls.start_lng > str(start_lng - deg))\n ))\n\n if kwargs.get('end_lat'):\n deg = float(kwargs.get('deg'))\n end_lat = float(kwargs.get('end_lat'))\n end_lng = float(kwargs.get('end_lng'))\n q = q.filter(\n ( (cls.end_lat < str(end_lat + deg)) &\n (cls.end_lat > str(end_lat - deg))\n ) &\n ( (cls.end_lng < str(end_lng + deg)) &\n (cls.end_lng > str(end_lng - deg))\n ))\n\n\n if kwargs.get('date_from'):\n date_from = kwargs.get('date_from')\n\n q = q.filter((cast(cls.start_timestamp, Date) >= date_from))\n\n if kwargs.get('date_to'):\n date_to = kwargs.get('date_to')\n \n q = q.filter((cast(cls.start_timestamp, Date) <= date_to))\n\n # print '\\n\\nhiii: {}\\n\\n'.format(kwargs.get('start_time'))\n \n # q = q.filter(cast(cls.start_timestamp, Time) >= start_time)\n # if kwargs.get('start_time') >= '00:00:00' kwargs.get('start_time') and < \"00:08:00\":\n # pass\n\n # print '\\n\\n\\n*STARTTIME*\\n{}, {}\\n\\n\\n'.format(start_time, type(start_time))\n\n # q = q.filter(cast(cls.start_timestamp, Time) >= start_time)\n\n if kwargs.get('cost'):\n cost = int(kwargs.get('cost'))\n q = q.filter(cls.cost < cost)\n\n start_time = kwargs.get('start_time')\n if start_time >= time(0,0) and start_time < time(8,0):\n q1 = q.filter(cast(cls.start_timestamp, Time) >= start_time)\n q2 = q.filter(cast(cls.start_timestamp, Time) < time(8, 0))\n q = q1.intersect(q2)\n else:\n q1 = q.filter(cast(cls.start_timestamp, Time) >= start_time)\n q2 = q.filter(cast(cls.start_timestamp, Time) < time(8, 0))\n q = q1.union(q2)\n\n if kwargs.get('order_by') == 'date':\n q = q.order_by(cls.start_timestamp)\n\n if kwargs.get('order_by') == 'time':\n sort_order = case(value=(cast(cls.start_timestamp, Time)), whens=order_by_time)\n q = q.order_by(sort_order)\n\n if kwargs.get('order_by') == 'cost':\n q = q.order_by(cls.cost)\n\n if kwargs.get('limit'):\n limit_number = int(kwargs.get('limit'))\n q = q.limit(limit_number)\n\n if kwargs.get('offset'):\n offset_number = int(kwargs.get('offset'))\n q = q.offset(offset_number)\n\n if kwargs.get('count'):\n rides = q.count()\n else:\n rides = q.all()\n print '\\n\\n{}\\n\\n'.format(rides)\n\n return rides","def get_queryset(self):\n\n fl = self.request.QUERY_PARAMS.get('fl', None)\n win = self.request.QUERY_PARAMS.get('win', None)\n win_filter = Q(orderstatus__in=['Shipped', 'Unshipped', 'Processing'], fulfillmentchannel='MFN')\n #win_filter = Q(orderstatus__in=['Unshipped', 'Processing'], fulfillmentchannel='MFN')\n\n queryset = None\n if fl is not None and fl.isdigit():\n logger.info(\"Got filter id: %s\", fl)\n try:\n filter = Filter.objects.get(pk=int(fl))\n if filter:\n ancestor_logic = Q() #Create Q object to hold other query\n #If filter is only root node\n if filter.is_root_node():\n ancestor_logic = pickle.loads(filter.logic) #Deserilize the filter logic\n logger.info(\"Filter has only root node, Logic: %s\", ancestor_logic)\n\n #If filter has parents\n else:\n for filter_data in filter.get_ancestors(False, True): #Get all parents including self\n filter_logic = pickle.loads(filter_data.logic) #Deserilize the filter logic\n if ancestor_logic.__len__()==0:\n ancestor_logic = filter_logic\n else:\n ancestor_logic = ancestor_logic & filter_logic\n logger.info(\"Filter has parents, Logic: %s\", ancestor_logic)\n\n if ancestor_logic:\n queryset = AmazonOrders.objects.filter(ancestor_logic & win_filter) #pass the query object to filter\n logger.info(\"Filter query, Query: %s\", queryset.query)\n\n except Exception as e:\n logger.error(\"In queryset exception : %s\",e)\n elif win is not None:\n logic = None\n if win == 'AFN':\n logic = Q(fulfillmentchannel=win, orderstatus='Shipped')\n elif win in ['Pending', 'Canceled']:\n logic = Q(orderstatus=win)\n elif win == 'Unshipped':\n logic = Q(orderstatus=win)\n\n if logic:\n queryset = AmazonOrders.objects.filter(logic)\n logger.info(\"Win query, Query: %s\", queryset.query)\n\n else:\n #queryset = AmazonOrders.objects.all()\n queryset = AmazonOrders.objects.filter(win_filter)\n logger.info(\"Filter not passed, Processing full Query: %s\", queryset.query)\n\n return queryset","def offers_list(update, context):\n chat = Chat.get(update.message.chat_id)\n\n if not chat.cart.subscriptions:\n text = 'ℹ️ Du får ingen tilbud, hvis du ikke har nogen søgninger.'\n update.message.reply_text(text)\n\n for sub in chat.cart:\n if not sub.offers:\n text = f'ℹ️ Søgningen efter \"{sub.query}\" har ingen tilbud.'\n update.message.reply_text(text)\n continue\n\n lines = [\n f'ℹ️ Søgningen efter \"{sub.query}\" har {len(sub.offers)} tilbud:',\n ''\n ]\n for offer in sub.offers:\n print(offer, offer.timeleft(), offer.run_till)\n lines.append(offer_text(offer))\n\n update.message.reply_text('\\n'.join(lines))","def collect_events(helper, ew):\n\n opt_start_time_start = helper.get_arg('start_time_start')\n opt_endpoints = helper.get_arg('endpoints')\n opt_interval = int(helper.get_arg('interval'))\n opt_live = False\n\n proxy = helper.get_proxy()\n if proxy:\n proxy_auth = \"{}:{}\".format(\n proxy['proxy_username'], proxy['proxy_password'])\n proxies = {\n \"https\": \"{protocol}://{auth}@{host}:{port}/\".format(protocol=proxy['proxy_type'], auth=proxy, host=proxy['proxy_url'], port=proxy['proxy_port']),\n \"http\": \"{protocol}://{auth}@{host}:{port}/\".format(protocol=proxy['proxy_type'], auth=proxy, host=proxy['proxy_url'], port=proxy['proxy_port'])\n }\n else:\n proxies = None\n\n helper.log_debug(\n \"[-] webex password_type: {}\".format(helper.get_global_setting(\"password_type\")))\n\n params = {\"opt_username\": helper.get_global_setting(\"username\"),\n \"opt_password\": helper.get_global_setting(\"password\"),\n \"opt_site_name\": helper.get_global_setting(\"site_name\"),\n \"limit\": 500,\n \"timezone\": \"20\",\n # \"password_type\": authentication_type[\"Password Authentication\"],\n # \"password_type\": authentication_type[\"OAuth\"],\n \"password_type\": authentication_type[helper.get_global_setting(\"password_type\")],\n \"client_id\": helper.get_global_setting(\"client_id\"),\n \"client_secret\": helper.get_global_setting(\"client_secret\"),\n \"refresh_token\": helper.get_global_setting(\"refresh_token\"),\n \"proxies\": proxies}\n\n # Historical Data\n helper.log_debug(\"Historical Data\")\n for opt_endpoint in opt_endpoints:\n helper.log_debug(\"[-] \\t At {}\".format(opt_endpoint))\n\n # endtime is midnight of GMT - 3days\n enddt = datetime.utcnow().date() - timedelta(3)\n end_time = datetime.combine(\n enddt, datetime.max.time()).strftime('%m/%d/%Y %H:%M:%S')\n\n # create checkpoint key for offest and timestamp\n timestamp_key = \"timestamp_{}_{}_processing\".format(\n helper.get_input_stanza_names(), opt_endpoint)\n\n start_time = helper.get_check_point(timestamp_key)\n if start_time is None:\n # if it's the 1st time, get the start_time from UI, and then save it in checkpoint\n start_time = opt_start_time_start\n helper.save_check_point(timestamp_key, start_time)\n else:\n # shift the start_time by 1 second\n start_time = (datetime.strptime(start_time, '%m/%d/%Y %H:%M:%S') +\n timedelta(seconds=1)).strftime('%m/%d/%Y %H:%M:%S')\n\n helper.log_debug(\"Start time: {}\".format(start_time))\n helper.log_debug(\"End time: {}\".format(end_time))\n\n # Update Parameters\n params.update({\"mode\": \"historical\"})\n params.update({\"opt_endpoint\": opt_endpoint})\n params.update({\"start_time\": start_time})\n params.update({\"end_time\": end_time})\n params.update({\"timestamp_key\": timestamp_key})\n\n records = params['limit']\n offset = 1\n while (records == params['limit']):\n helper.log_debug(\"current_offset: {}\".format(offset))\n params['offset'] = offset\n records = fetch_webex_logs(ew, helper, params)\n helper.log_debug(\"\\t Offet:{}\\tLimit: {}\\tRecords Returned: {}\".format(\n offset, params['limit'], records))\n if records:\n offset += records","def get_queryset(self):\n day = self.request.query_params.get('day',None)\n tz = pytz.timezone('Europe/London') \n dt_now = datetime.now(tz=tz) - timedelta(minutes=10) \n day_name_today = dt_now.strftime(\"%A\")\n queryset = OnlineMeeting.objects.annotate(search=SearchVector('description','title'),)\n queryset = queryset.filter(published=True)\n\n search = self.request.query_params.get('search', None)\n\n if search is not None and len(search) > 0:\n queryset = queryset.filter(search=search)\n\n now = self.request.query_params.get('now',None)\n top = int(self.request.query_params.get('top',0))\n if day=='now':\n \n \n date_today = dt_now.date()\n time_now = dt_now.time()\n datetime_now = datetime.combine(date_today,time_now)\n \n tomorrow = dt_now + timedelta(days=1) \n day_name_tomorrow = tomorrow.strftime(\"%A\")\n \n meetings_today = OnlineMeeting.objects.filter(((Q(day=day_name_today) | Q(day='All')) & Q(time__gte=dt_now.time())))#.order_by('time')\n meetings_tomorrow = OnlineMeeting.objects.filter((Q(day=day_name_tomorrow) & Q(time__lte=dt_now.time())))#.order_by('time')\n \n\n all = meetings_today #| meetings_tomorrow\n if day_name_today == 'sunday':\n all_ordered = all.order_by('time')\n else:\n all_ordered = all.order_by('time')\n \n if top:\n all_ordered = all_ordered[:top]\n return all_ordered#.annotate(the_rank=rank_by_day)\n elif day in ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']:\n queryset = queryset.filter(Q(day=day) | Q(day='All') )\n \n \n \n \n \n return queryset.order_by('time')","def dmd_metric_filter_query(self): \n \n metric_filter_query = \"\"\"\n , elig_device_metrics as (\n -- For eligible devices, pull their whole history for the metric we want to filter\n SELECT \n d.device_id,\n d.device_first_seen_ts,\n d.device_first_view_ts,\n d.platform,\n d.platform_type,\n d.ds,\n -- For filtering devices\n sum({cumul_filter_metric}) as daily_filter_metric\n FROM tubidw.device_metric_daily as d\n JOIN pre_approved_devices as p\n ON d.device_id = p.device_id\n GROUP BY 1,2,3,4,5,6\n )\n\n , elig_device_cumul_filter as (\n SELECT *, sum(daily_filter_metric) OVER (PARTITION BY device_id, platform_type, platform ORDER BY ds rows between unbounded preceding and current row) as cumul_filter_metric\n FROM elig_device_metrics\n )\n\n , elig_devices as (\n SELECT device_id\n FROM elig_device_cumul_filter\n GROUP BY 1\n HAVING 1=1\n -- cumulative metric filters dynamically populate below \n {metric_filter_having}\n -- example: \n -- AND max(cumul_filter_metric) >= 3600.0 -- at least 60 mins of cumulative TVT\n -- AND max(cumul_filter_metric) <= 3600.0 -- less than 60 mins of cumulative TVT\n )\n \"\"\"\n return metric_filter_query","def get_filtered_data(device_code, start_date = None, end_date=None, frequency = 'daily', pollutant = 'PM 2.5'):\r\n \r\n \r\n if start_date == None:\r\n start = str_to_date_find('2019-06-01T00:00:00Z')\r\n else:\r\n start = str_to_date(start_date)\r\n if end_date == None:\r\n end = datetime.now()\r\n else:\r\n end = str_to_date(end_date)\r\n \r\n query = { 'deviceCode': device_code, 'time': {'$lte': end, '$gte': start} }\r\n \r\n if pollutant == 'PM 10':\r\n projection = { '_id': 0, 'time': 1, 'characteristics.pm10ConcMass.value':1 }\r\n if frequency =='hourly':\r\n records = list(db.device_hourly_measurements.find(query, projection))\r\n elif frequency=='daily':\r\n records = list(db.device_daily_measurements.find(query, projection))\r\n else:\r\n records = list(db.device_raw_measurements.find(query, projection))\r\n for i in range(len(records)):\r\n if records[i]['characteristics']['pm10ConcMass']['value'] >0 and records[i]['characteristics']['pm10ConcMass']['value'] <=54:\r\n records[i]['backgroundColor'] = 'green'\r\n elif records[i]['characteristics']['pm10ConcMass']['value'] >54 and records[i]['characteristics']['pm10ConcMass']['value'] <=154:\r\n records[i]['backgroundColor'] = 'yellow'\r\n elif records[i]['characteristics']['pm10ConcMass']['value'] > 154 and records[i]['characteristics']['pm10ConcMass']['value'] <= 254:\r\n records[i]['backgroundColor'] = 'orange'\r\n elif records[i]['characteristics']['pm10ConcMass']['value'] > 254 and records[i]['characteristics']['pm10ConcMass']['value'] <= 354:\r\n records[i]['backgroundColor'] = 'red'\r\n elif records[i]['characteristics']['pm10ConcMass']['value'] > 354 and records[i]['characteristics']['pm10ConcMass']['value'] <= 424:\r\n records[i]['backgroundColor'] = 'purple'\r\n elif records[i]['characteristics']['pm10ConcMass']['value'] > 424 and records[i]['characteristics']['pm10ConcMass']['value'] <=604:\r\n records[i]['backgroundColor'] = 'maroon'\r\n else:\r\n records[i]['backgroundColor'] = 'gray'\r\n return records\r\n elif pollutant == 'NO2':\r\n projection = { '_id': 0, 'time': 1, 'characteristics.no2Conc.value':1 }\r\n if frequency =='hourly':\r\n records = list(db.device_hourly_measurements.find(query, projection))\r\n elif frequency=='daily':\r\n records = list(db.device_daily_measurements.find(query, projection))\r\n else:\r\n records = list(db.device_raw_measurements.find(query, projection))\r\n for i in range(len(records)):\r\n if records[i]['characteristics']['no2Conc']['value'] >0.0 and records[i]['characteristics']['no2Conc']['value'] <=53:\r\n records[i]['backgroundColor'] = 'green'\r\n elif records[i]['characteristics']['no2Conc']['value'] > 53 and records[i]['characteristics']['no2Conc']['value'] <=100:\r\n records[i]['backgroundColor'] = 'yellow'\r\n elif records[i]['characteristics']['no2Conc']['value'] > 100 and records[i]['characteristics']['no2Conc']['value'] <= 360:\r\n records[i]['backgroundColor'] = 'orange'\r\n elif records[i]['characteristics']['no2Conc']['value'] > 360 and records[i]['characteristics']['no2Conc']['value'] <= 649:\r\n records[i]['backgroundColor'] = 'red'\r\n elif records[i]['characteristics']['no2Conc']['value'] > 649 and records[i]['characteristics']['no2Conc']['value'] <= 1249:\r\n records[i]['backgroundColor'] = 'purple'\r\n elif records[i]['characteristics']['no2Conc']['value'] > 1249 and records[i]['characteristics']['no2Conc']['value'] <=2049:\r\n records[i]['backgroundColor'] = 'maroon'\r\n else:\r\n records[i]['backgroundColor'] = 'gray'\r\n return records\r\n else:\r\n projection = { '_id': 0, 'time': 1, 'characteristics.pm2_5ConcMass.value':1 }\r\n if frequency =='hourly':\r\n records = list(db.device_hourly_measurements.find(query, projection))\r\n elif frequency=='daily':\r\n records = list(db.device_daily_measurements.find(query, projection))\r\n else:\r\n records = list(db.device_raw_measurements.find(query, projection))\r\n for i in range(len(records)):\r\n if records[i]['characteristics']['pm2_5ConcMass']['value'] >0.0 and records[i]['characteristics']['pm2_5ConcMass']['value'] <=12.0:\r\n records[i]['backgroundColor'] = 'green'\r\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] >12.0 and records[i]['characteristics']['pm2_5ConcMass']['value'] <=35.4:\r\n records[i]['backgroundColor'] = 'yellow'\r\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] > 35.4 and records[i]['characteristics']['pm2_5ConcMass']['value'] <= 55.4:\r\n records[i]['backgroundColor'] = 'orange'\r\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] > 55.4 and records[i]['characteristics']['pm2_5ConcMass']['value'] <= 150.4:\r\n records[i]['backgroundColor'] = 'red'\r\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] > 150.4 and records[i]['characteristics']['pm2_5ConcMass']['value'] <= 250.4:\r\n records[i]['backgroundColor'] = 'purple'\r\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] > 250.4 and records[i]['characteristics']['pm2_5ConcMass']['value'] <=500.4:\r\n records[i]['backgroundColor'] = 'maroon'\r\n else:\r\n records[i]['backgroundColor'] = 'gray'\r\n return records","def _filter_data(analyzed_tweet_data: list, start_date, end_date, hashtags, mentions, urls):\n # filter by dates\n filtered_data = get_tweets_in_daterange(\n analyzed_tweet_data, start_date, end_date)\n print(\"Done filtering on date...\")\n if hashtags:\n filtered_data = _filter_search_values(\n 'hashtags', hashtags, filtered_data)\n print(f'Done filtering on hashtags: {hashtags}')\n if mentions:\n filtered_data = _filter_search_values(\n 'mentions', mentions, filtered_data)\n print(f'Done filtering on mentions: {mentions}')\n if urls:\n filtered_data = _filter_search_values(\n 'tweet_urls', urls, filtered_data)\n print(f'Done filtering on urls: {urls}')\n\n return filtered_data","def data_filter(\n df, CondTempRange=[float('-inf'), float('inf')],\n EvapTempRange=[float('-inf'), float('inf')],\n RemovalPoint=[OperatingPoint()],\n AddPoint=[OperatingPoint()]\n ):\n\n # copy new dataframe\n df_new = copy.deepcopy(df)\n\n # condition list\n cond = []\n cond.append(df.CondTempInF >= CondTempRange[0])\n cond.append(df.CondTempInF <= CondTempRange[1])\n cond.append(df.EvapTempInF >= EvapTempRange[0])\n cond.append(df.EvapTempInF <= EvapTempRange[1])\n for point in RemovalPoint:\n cond.append(df.OperatingPoint != point)\n addcond = []\n for point in AddPoint:\n addcond.append(df.OperatingPoint == point)\n\n # Apply AND to all conditions\n final_condition = cond[0]\n for ii in xrange(1, len(cond)):\n final_condition = final_condition*cond[ii]\n\n # Apply OR to all conditions\n for ii in xrange(0, len(addcond)):\n final_condition = final_condition+addcond[ii]\n\n # Return the data that satisfy all conditions\n return df_new[final_condition]","def build_query(devices, filter_inter, interactions_further=None):\n\n id_2_found = CsvFormat.other_id.value\n if interactions_further is not None:\n id_2_found = CsvFormat.my_id.value\n\n query = 'SELECT i._{} as id, CAST(i._{} as int) as timestamp_start, CAST(i._{} as float) as interval_time ' \\\n 'FROM S3Object i WHERE CAST(i._{} as float) >= {}'.format(\n id_2_found,\n CsvFormat.timestamp_start.value,\n CsvFormat.interval.value,\n CsvFormat.interval.value,\n MINIMUM_INTERVAL_TIME)\n\n if 'distance' in filter_inter:\n if 'max' in filter_inter['distance']:\n query += ' and CAST(i._{} as float) <= {}'.format(CsvFormat.distance_type.value,\n filter_inter['distance']['max'])\n if 'min' in filter_inter['distance']:\n query += ' and CAST(i._{} as float) >= {}'.format(CsvFormat.distance_type.value,\n filter_inter['distance']['min'])\n\n if interactions_further is not None:\n condos = []\n for inter in interactions_further:\n orcond = '(i._{}=\\'{}\\' and (CAST(i._{} as float) between {} and {} or CAST(i._{} as float) between {} and {}))'\\\n .format(CsvFormat.other_id.value,\n inter['id'],\n CsvFormat.timestamp_start.value,\n inter['timestamp_start'],\n int(inter['timestamp_start'] + inter['interval_time']),\n CsvFormat.timestamp_end.value,\n inter['timestamp_start'],\n int(inter['timestamp_start'] + inter['interval_time'])\n )\n condos.append(orcond)\n if len(condos) > 0:\n query += ' and ' + ' or '.join(condos)\n else:\n query += ' and i._{} in (\\'{}\\')'.format(\n CsvFormat.my_id.value,\n '\\',\\''.join([str(x) for x in devices])\n )\n\n return query","def filter_listings(listing):\n\n MIN_PRICE = program_features.MIN_PRICE\n MAX_PRICE = program_features.MAX_PRICE\n\n MAX_DISTANCE = program_features.MAX_DISTANCE\n\n MIN_NUM_ROOMS = program_features.MIN_NUM_ROOMS\n MAX_NUM_ROOMS = program_features.MAX_NUM_ROOMS\n\n if (float(listing.price[1:4]) < MIN_PRICE) or (float(listing.price[1:4]) > MAX_PRICE):\n print (\"Listing price = {}\".format(listing.price[1:4], ))\n return False\n elif (float(listing.distance) > MAX_DISTANCE):\n print (\"Listing distance = {}\".format(float(listing.distance)))\n return False\n elif (int(listing.rooms) < MIN_NUM_ROOMS) or (int(listing.rooms) > MAX_NUM_ROOMS) :\n print (\"Listing rooms = {}\".format(int(listing.rooms)))\n return False\n else:\n return True","def apply_search_filters():\n params = {'api_key': API_KEY}\n for k in demisto.args():\n if demisto.getArg(k):\n params['term'] = k\n params['query'] = demisto.getArg(k)\n break\n return params","def filter_dataframe(df, start_date_dt, end_date_dt):\n\n dff = df \n # df[\n # (df[\"timestamp\"].dt.date >= dt.date(start_date_dt.year, start_date_dt.month, start_date_dt.day))\n # & (df[\"timestamp\"].dt.date <= dt.date(end_date_dt.year, end_date_dt.month, end_date_dt.day))\n # ]\n # if (lat_min != -90) or (lat_max != 90):\n # dff = dff[\n # (dff[\"lat\"] >= lat_min)\n # & (dff[\"lat\"] <= lat_max)\n # ]\n # if (lon_min != -90) or (lon_max != 90):\n # dff = dff[\n # (dff[\"lon\"] >= lon_min)\n # & (dff[\"lon\"] <= lon_max)\n # ]\n\n return dff","def filter_items(self, filter_data: Dict[str, str] = None) -> List[WalletItem]:\n filtered_items = self.items\n for key, value in filter_data.items():\n if key == \"category\":\n filtered_items = [item for item in filtered_items\n if re.search(value, item.category, re.IGNORECASE)]\n if key == \"account\":\n filtered_items = [item for item in filtered_items\n if re.search(value, item.account, re.IGNORECASE)]\n if key == \"notes\" in filter_data:\n filtered_items = [item for item in filtered_items\n if re.search(value, item.notes, re.IGNORECASE)]\n if key == \"amt_min\":\n value = float(value)\n filtered_items = [item for item in filtered_items if item.amount >= value]\n if key == \"amt_max\":\n value = float(value)\n filtered_items = [item for item in filtered_items if item.amount <= value]\n if key == \"begin_date\":\n try:\n begin_date = datetime.strptime(value, '%d/%m/%Y')\n filtered_items = [item for item in filtered_items if begin_date <= item.date]\n except ValueError as ex:\n print(ex)\n exit(1)\n if key == \"end_date\":\n try:\n end_date = datetime.strptime(value, '%d/%m/%Y')\n filtered_items = [item for item in filtered_items if item.date <= end_date]\n except ValueError as ex:\n print(ex)\n exit(1)\n return filtered_items","def get_queryset(self):\n #return Poll.objects.filter(pub_date__lte=timezone.now())\n return Poll.objects.annotate(num_choices=Count('choice')).filter(pub_date__lte=timezone.now(), num_choices__gte=2)","def get_filters(self):","def add_event_filter(_filter, event_type, date_min=None):\n\n if event_type == 'PLANNED':\n if date_min:\n _filter['endDate'] = {\n 'operation': 'greaterThanDate',\n 'options': [{\n 'name': 'date',\n 'value': [date_min]\n }]\n }\n else:\n _filter['endDate'] = {\n 'operation': '> sysdate - 2'\n }\n _filter['startDate'] = {\n 'operation': 'orderBy',\n 'options': [{\n 'name': 'sort',\n 'value': ['DESC']\n }]\n }\n\n if event_type == 'UNPLANNED_INCIDENT':\n if date_min:\n _filter['modifyDate'] = {\n 'operation': 'greaterThanDate',\n 'options': [{\n 'name': 'date',\n 'value': [date_min]\n }]\n }\n else:\n _filter['modifyDate'] = {\n 'operation': '> sysdate - 2'\n }\n\n if event_type == 'ANNOUNCEMENT':\n _filter['statusCode'] = {\n 'keyName': {\n 'operation': 'in',\n 'options': [{\n 'name': 'data',\n 'value': ['PUBLISHED']\n }]\n }\n }","def filter_dt(tp,ts, show_plot, lower_delta,min_len):\n import numpy\n import matplotlib.pyplot as plt\n ####################################\n def array_none_removal(array_dt):\n output=[]\n for index in range(len(array_dt)):\n if array_dt[index]!=None:\n output.append(array_dt[index])\n return(output)\n \n ####################################\n # Calculate delta t based in P and S1 arrival\n delta_t=[]\n for gph_index in range(len(tp)):\n # verify is the pp and sp1 are NOT nan\n if tp[gph_index]!=None and ts[gph_index]!=None:\n #if (not math.isnan(tp[gph_index])) and (not math.isnan(ts[gph_index])):\n delta_t.append(ts[gph_index]-tp[gph_index])\n else:\n delta_t.append(None)\n\n ####################################\n #%% Filter delta_t\n \n # Remove Nones from delta t to calculate its stats\n dt_numbers=array_none_removal(delta_t)\n dt_numbers=list(filter(lambda x:x>0.25, dt_numbers)) # remove values lower than 0.2\n \n # Build the new delta_t array with outliers removed\n dt_filtered=[]\n \n for dt_index in range(len(delta_t)):\n if delta_t[dt_index]!= None:\n if delta_t[dt_index] <= (numpy.median(dt_numbers)+numpy.std(dt_numbers)) and delta_t[dt_index] >= (numpy.median(dt_numbers)-numpy.std(dt_numbers)) and delta_t[dt_index]>=lower_delta:\n dt_filtered.append(delta_t[dt_index])\n else:\n dt_filtered.append(None)\n else:\n dt_filtered.append(None)\n \n dt_filtered_numbers=array_none_removal(dt_filtered)\n #print('Len filtered ',len(dt_filtered_numbers))\n \n ####################################\n if show_plot==True:# and len(dt_filtered_numbers)>=min_len: \n plt.figure(1, figsize=(8,1))\n plt.plot(dt_filtered,'.k')\n plt.axhline(y=numpy.median(dt_numbers),c='g', linestyle='--')#, lw=0.5)\n plt.axhline(y=numpy.median(dt_numbers)+numpy.std(dt_numbers),c='r', linestyle=':')#, lw=0.5)\n plt.axhline(y=numpy.median(dt_numbers)-numpy.std(dt_numbers),c='r', linestyle=':')#,lw=0.5)\n plt.ylim(0.5,1.5)\n plt.xlabel('Gph id')\n plt.ylabel('ts -tp (s)')\n plt.title('ATP ts-tp') \n plt.show()\n plt.close()\n #################################### \n return(dt_filtered,dt_filtered_numbers)","def queryset(self, request):\n qs = super(AdRepConsumerAdmin, self).queryset(request)\n qs = AdRepConsumer.objects.select_related().filter(id__in=qs\n ).defer('consumer__site__envelope',\n 'consumer__site__geom',\n 'consumer__site__point')\n return qs","def queryset(self, request, queryset):\n if self.value() == 'syndicated':\n return queryset.filter(syndicated_at__isnull=False)\n if self.value() == 'ready_to_syndicate':\n return queryset.filter(ignored_at=None,\n syndicated_at=None,\n longitude_position__isnull=False,\n merchantwebsite__deleted_at=None,\n merchantdoc__deleted_at=None,\n ).distinct()\n if self.value() == 'ignore':\n return queryset.filter(ignored_at__isnull=False)","def _query_builder(self,\n start_date=None,\n end_date=None,\n clipper=None\n ):\n search_string='format=json&lang=fr&q='\n if (start_date is not None):\n if(end_date is not None):\n search_string+='entre+'+start_date+'+et+'+end_date\n else:\n search_string+=start_date\n elif(end_date is not None): \n search_string+=end_date\n \n if(clipper.query is not None):\n query=clipper.query.replace(' ','+')\n search_string+='+'+query\n if(clipper.bbox is not None):\n search_string+='&box='+clipper.bbox\n\n return search_string","def filter_geomag(inst, min_kp=0, max_kp=9, filter_time=24, kp_inst=None):\n # Load the desired data\n if kp_inst is None:\n kp_inst = pysat.Instrument(inst_module=pysat_sw.instruments.sw_kp,\n tag='', pad=pds.DateOffset(days=1))\n\n if kp_inst.empty:\n kp_inst.load(date=inst.date, verifyPad=True)\n\n # Begin filtering, starting at the beginning of the instrument data\n sel_data = kp_inst[(inst.date - pds.DateOffset(days=1)):\n (inst.date + pds.DateOffset(days=1))]\n ind, = np.where((sel_data['Kp'] > max_kp) | (sel_data['Kp'] < min_kp))\n for lind in ind:\n sind = sel_data.index[lind]\n eind = sind + pds.DateOffset(hours=filter_time)\n inst[sind:eind] = np.nan\n inst.data = inst.data.dropna(axis=0, how='all')\n\n return","def solve_filter_time_interval(self):\n if 'interval' in self.filter_request:\n temp_list_pack = []\n temp_list_pack.append(self.list_pack[0])\n curr_time = pandas.to_datetime(self.list_pack[0]['time_stamp'])\n filter_interval = int(self.filter_request['interval'])\n\n if filter_interval <= 0:\n filter_interval = int(1)\n\n for i in self.list_pack:\n pack_time = pandas.to_datetime(i['time_stamp'])\n if (curr_time + pandas.to_timedelta(filter_interval, unit='s')) <= pack_time:\n temp_list_pack.append(i)\n curr_time = pandas.to_datetime(i['time_stamp'])\n\n self.list_pack = temp_list_pack","def apply_20percent_shipping_offer(self):\n product_range = Range.objects.create(\n name=\"All products range\", includes_all_products=True\n )\n benefit = Benefit.objects.create(\n range=product_range, type=Benefit.SHIPPING_PERCENTAGE, value=20\n )\n offer = factories.create_offer(product_range=product_range, benefit=benefit)\n Applicator().apply_offers(self.basket, [offer])\n return offer","def og_features(scan,filt=None,base_noise=None,thresh=-1.4781e-10,diff=1,verbose=False,scale=10):\n #get gradients of data\n der = np.array(np.gradient(scan,diff))\n \n #calculate gardient magnitudes and directions\n der_mag = np.linalg.norm(der,axis=0) \n der_uvecs = der/der_mag\n \n z_cur = np.copy(scan).ravel()\n\n #estimate noise level and set derivative filter threshold\n if filt is None:\n filt = np.mean(signaltonoise(der_mag)[-1])\n \n \n if base_noise is not None:\n filt = np.maximum(filt,base_noise)\n \n\n\n #filter directions and magnitudes\n x, y, z = der_uvecs[0].ravel(), der_uvecs[1].ravel(), der_mag.ravel()\n \n #filter using threshold and filt\n x_filt, y_filt, z_filt = x[z_cur>thresh], y[z_cur>thresh], z[z_cur>thresh]\n #x_filt, y_filt, z_filt = x, y, z\n\n \n #print(len(z_filt))\n x_filt, y_filt, z_filt = x_filt[z_filt>filt], y_filt[z_filt>filt], z_filt[z_filt>filt]\n\n \n #calculate angles\n angles_filt = np.sign(y_filt)*np.arccos(x_filt/1)\n\n \n #print(len(angles_filt))\n \n if len(angles_filt) < 2:\n return 0,0,0\n \n #fit single line\n sol1 = least_squares(ress_1line,[-np.pi/2],args=(angles_filt,),bounds=[-np.pi,0],method='dogbox',jac='2-point',max_nfev=2000)\n\n #fit two lines by grid search\n #sol_grid = grid_search(ress_2line,angles_filt,[[-np.pi,0],[-np.pi,0]])\n \n \n singleline = sol1.x[0]\n \n mx = np.minimum(np.abs(singleline-(-np.pi)),np.abs(singleline))\n \n sol_grid = grid_search(ress_2line_pm,angles_filt,[[0,mx]],umid = singleline)\n spread_lines = sol_grid[1]\n sol_grid[1] = [singleline+spread_lines,singleline-spread_lines]\n \n \n #compute average of squared residuals for both cases\n resid1 = ress_1line(sol1.x,angles_filt)\n\n grid_c11 = np.average(np.power(resid1,2))\n \n grid_c11 = np.average(np.abs(resid1))\n \n grid_c21 = sol_grid[-1]\n \n \n multip = cotunnel_score2(scan,scan>thresh,diff,scale)\n \n final_grid2 = multip*(grid_c11-grid_c21)\n \n \n \"\"\"\n plt.scatter(angles_filt,z_filt,marker='x',c='k',s=15,linewidth=0.4)\n plt.axvline(sol1.x,color='b')\n plt.axvline(sol1.x+(np.pi),color='b')\n plt.axvline(sol_grid[1][0],0,color='r', linestyle='--')\n plt.axvline(sol_grid[1][1],0,color='r', linestyle='--')\n \n plt.axvline(sol_grid[1][0]+(np.pi),0,color='r', linestyle='--')\n plt.axvline(sol_grid[1][1]+(np.pi),0,color='r', linestyle='--')\n \n plt.xlabel(\"$\\\\theta_g$ / rad\")\n \n plt.xlim([-np.pi,np.pi])\n plt.ylim([0,z.max()])\n \n \n plt.ylabel(\"$|g|$\")\n \n plt.xticks([-np.pi,0,np.pi])\n \n plt.locator_params(axis='y', nbins=2)\n \n plt.savefig(\"og_fig.svg\")\n \n plt.show()\n \"\"\"\n return final_grid2,multip,(grid_c11-grid_c21)","def _make_query_result(self, cr , uid, data, context=None):\n search_criterea = ''\n #Date Wise Bifurcation\n if data.type == 'date':\n start = data.start_date\n end = data.end_date\n if start and end:\n start = self.date_to_datetime(cr, uid, start + ' 00:00:00', context=context)\n end = self.date_to_datetime(cr, uid, end + ' 23:59:59', context=context)\n search_criterea += \" AND mp.date_planned > '\" + str(start) + \"' AND mp.date_finished < '\" + str(end) + \"' \"\n elif start:\n start = self.date_to_datetime(cr, uid, start + ' 00:00:00', context=context)\n search_criterea += \" AND mp.date_planned > '\" + str(start) + \"' \"\n elif end:\n end = self.date_to_datetime(cr, uid, end + ' 23:59:59', context=context)\n search_criterea += \" AND mp.date_finished < '\" + str(end) + \"' \"\n else:\n #Number Wise Bifurcation\n number_from = data.number_from\n number_to = data.number_to\n if number_from <= 0 or number_to <= 0:\n raise osv.except_osv(_('Warning!'), _('Negative or Zero number not allow to pass!'))\n if number_from > 0 and number_to > 0:\n if number_from > number_to:\n raise osv.except_osv(_('Warning!'), _('Please correct the number place.\\nNumber To must be greater then Number From.'))\n count, comma = 0, True\n if number_from == number_to:\n comma = False\n for r in range(number_from, number_to + 1):\n count += 1\n if count == 1: search_criterea += \" AND mp.name SIMILAR TO '%(\"\n search_criterea += str(r)\n if comma and (r <> number_to): search_criterea += '|'\n if r == number_to: search_criterea += \")%'\"\n #State Wise Bifurcation\n if data.draft or data.in_production or data.ready or data.done or data.cancel or data.confirmed or data.picking_except:\n if not search_criterea: search_criterea += ' AND mp.state in ('\n else:\n search_criterea += ' AND mp.state in ('\n j_s = ''\n if data.draft: j_s += \"'draft',\"\n if data.in_production: j_s += \"'in_production',\"\n if data.ready: j_s += \"'ready',\"\n if data.done: j_s += \"'done',\"\n if data.cancel: j_s += \"'cancel',\"\n if data.confirmed: j_s += \"'confirmed',\"\n if data.picking_except: j_s += \"'picking_except',\"\n search_criterea += j_s[:-1]+')'\n if search_criterea: search_criterea = ' WHERE mpwl.production_id = mp.id ' + search_criterea\n #Merged this query criterea for execution\n cr.execute(\"\"\" SELECT mpwl.id FROM mrp_production mp, mrp_production_workcenter_line mpwl \"\"\"+ search_criterea)\n return [r[0] for r in cr.fetchall()]","def get_filtered_dataX(device_code, start_date = None, end_date=None, frequency = 'daily', pollutant = 'PM 2.5'):\r\n if start_date == None:\r\n start = str_to_date_find('2019-06-01T00:00:00Z')\r\n else:\r\n start = str_to_date(start_date)\r\n if end_date == None:\r\n end = datetime.now()\r\n else:\r\n\r\n end = str_to_date(end_date)\r\n\r\n query = {'$match':{ 'deviceCode': device_code, 'time': {'$lte': end, '$gte': start} }}\r\n \r\n if pollutant == 'PM 10': \r\n projection = { '$project': { '_id': 0, \r\n 'time': {'$dateToString':{ 'format': '%Y-%m-%dT%H:%M:%S%z', 'date': '$time', 'timezone':'Africa/Kampala'}}, \r\n 'pollutant_value': {'$round':['$characteristics.pm10ConcMass.value',2]} }}\r\n elif pollutant == 'NO2': \r\n projection = { '$project': { '_id': 0, \r\n 'time': {'$dateToString':{ 'format': '%Y-%m-%dT%H:%M:%S%z', 'date': '$time', 'timezone':'Africa/Kampala'}}, \r\n 'pollutant_value': {'$round':['$characteristics.no2Conc.value',2]} }} \r\n else: \r\n projection = { '$project': { '_id': 0, \r\n 'time': {'$dateToString':{ 'format': '%Y-%m-%dT%H:%M:%S%z', 'date': '$time', 'timezone':'Africa/Kampala'}}, \r\n 'pollutant_value': {'$round':['$characteristics.pm2_5ConcMass.value',2]} }} \r\n \r\n \r\n if frequency =='hourly':\r\n records = db.device_hourly_measurements.aggregate([query, projection]) \r\n elif frequency == 'monthly':\r\n results = list(db.device_daily_measurements.aggregate([query, projection]))\r\n records = resample_timeseries_data(results, 'M', 'time', 2)\r\n else:\r\n records = db.device_daily_measurements.aggregate([query, projection])\r\n\r\n \r\n return list(records)","def daily_search(term, state='', property=''):\n geo = \"\"\n if state == '':\n geo = state = 'US'\n else:\n geo = 'US-' + state\n\n out = service.getGraph(terms=term,\n restrictions_startDate='2008-01',\n restrictions_endDate='2008-07',\n restrictions_geo=geo,\n restrictions_property=property).execute().get('lines')[0].get('points')\n\n next = service.getGraph(terms=term,\n restrictions_startDate='2008-07',\n restrictions_endDate='2009-01',\n restrictions_geo=geo,\n restrictions_property=property).execute().get('lines')[0].get('points')\n\n #out['orig_value'] = out['value']\n #next['orig_value'] = next['value']\n\n multiplier = 1\n if next[30].get('value') != 0:\n multiplier = out[-1].get('value')/next[30].get('value')\n if multiplier == 0:\n multiplier = 1\n\n for i in next:\n i['value'] = i['value']*multiplier\n\n out = out + next[31:]\n\n for i in range(2009,2019):\n print(term + ', ' + property + ', ' + str(i))\n n = i + 1\n for j in range(1,3):\n if j == 1:\n s = str(i) + '-01'\n e = str(i) + '-07'\n else:\n s = str(i) + '-07'\n e = str(i + 1) + '-01'\n\n next = service.getGraph(terms=term,\n restrictions_startDate=s,\n restrictions_endDate=e,\n restrictions_geo=geo,\n restrictions_property=property).execute().get('lines')[0].get('points')\n\n #next['orig_value'] = next['value']\n\n multiplier = 1\n if next[30].get('value') != 0:\n multiplier = out[-1].get('value')/next[30].get('value')\n if multiplier == 0:\n multiplier = 1\n\n for k in next:\n k['value'] = k['value']*multiplier\n\n out = out + next[31:]\n\n\n\n\n if property == '':\n property = 'web'\n\n df1 = pd.DataFrame(out)\n\n df1['term'] = term\n df1['state'] = state\n df1['property'] = property\n\n return df1","def accepted_query_params(self):\n # date range related.\n days_range = arrow.Arrow.range(\"day\",\n ArrowParameter.get(self.date_begin),\n ArrowParameter.get(self.date_end))\n accepted_date_values = sorted(map(str, days_range))\n\n # result\n return {\n \"date_value\": accepted_date_values,\n \"task_cls\": self.ptm.task_class_names,\n \"luiti_package\": self.ptm.task_package_names,\n }","def filter_on_adwin_parameters(a_lt3,a_lt4,**kw):\r\n\r\n filter_params = kw.pop('adwin_filter_params',{})\r\n if len(filter_params):\r\n old_params = analysis_params.SPSP_fltr_adwin_settings\r\n \r\n for setup_key,setup_dict in filter_params.iteritems():\r\n for key,params in setup_dict.iteritems():\r\n analysis_params.SPSP_fltr_adwin_settings['fltr_dict_'+setup_key][key] = params\r\n\r\n fltr = np.array([True]*len(a_lt3.agrp['ssro_results'].value)) ### initially everything true\r\n\r\n for a,suffix in zip([a_lt3,a_lt4],['lt3','lt4']): ### loop over both files\r\n for key,val in analysis_params.SPSP_fltr_adwin_settings['fltr_dict_'+suffix].iteritems(): ### loop over the list of filter parameters\r\n [filter_on,minimum,maximum] = val\r\n\r\n if filter_on:\r\n if key == 'repetition_number':\r\n values = np.array([i for i in range(len(fltr)/a.g.attrs['sweep_length']) for _ in range(a.g.attrs['sweep_length'])]) ### Make an array of values corresponding to the current rep\r\n else:\r\n values = a.agrp[key].value\r\n\r\n fltr = np.logical_and(fltr,(values >= minimum) & ( values <= maximum)) ### update filter\r\n\r\n if len(filter_params):\r\n analysis_params.SPSP_fltr_adwin_settings = old_params\r\n\r\n return fltr","def amh_attr_filter_query(self):\n \n attr_filter_query = \"\"\"\n WITH {final_cte_name} as (\n -- Pull list of devices that were active (has any row; don't need TVT >0) in the past 4 weeks\n SELECT DISTINCT device_id\n FROM tubidw.all_metric_hourly\n WHERE DATE_TRUNC('week',hs) >= dateadd('week',-4,DATE_TRUNC('week',GETDATE()))\n AND DATE_TRUNC('week',hs) < DATE_TRUNC('week',GETDATE())\n {attr_filter} -- attribute filters dynamically populate here\n -- TODO: currently can't get a metric/attribute combo filter, like \"devices that watched at least 50% of a specific content_id\"\n )\n \"\"\"\n return attr_filter_query","def premium_set_search_params(self, search_query, from_date, to_date,\n no_retweets=True, results_per_call=500):\n \n # Set a static Language Filter for English Tweets\n lang_filter = ' lang:en'\n if no_retweets:\n rt_filter = ' -is:retweet'\n # Adds an ignore Retweets tag to the (Altcoin) Query\n self.query = search_query + lang_filter + rt_filter\n else:\n # This Query includes all Tweets, also Retweets\n self.query = search_query + lang_filter\n # Sets the Rule for the Query to be executed (time frame & # of Results)\n self.rule = gen_rule_payload(self.query, results_per_call=results_per_call,\n from_date=from_date, to_date=to_date)","def suggest_similar_activities(self, *, elev_gain=None, distance=None, dist_fudge=0.1, elev_fudge=0.1, metric=False, activity_type=\"Ride\", open_web=False) :\n\n # You need to have at least one of elevation gain and distance.\n if elev_gain == None and distance == None :\n raise ValueError(\"elev_gain and distance can't both equal None.\")\n\n csv_file = activity_type + \".csv\"\n try:\n actDF = pd.read_csv(csv_file, index_col=\"id\", parse_dates=[\"start_date\", \"start_date_local\"])\n except FileNotFoundError:\n print(csv_file, \"file does not exist. Record some of that activity and try again.\")\n else:\n # Sort out what units we're using.\n if not metric :\n dist_key = \"distance(miles)\"\n elev_gain_key = \"elevation_gain(ft)\"\n dist_units = \"miles\"\n elev_units = \"feet\"\n else:\n dist_key = \"distance(km)\"\n elev_gain_key = \"total_elevation_gain\"\n dist_units = \"km\"\n elev_units = \"meters\"\n\n # Deal with three situations: We have elevation gain and distance. We have\n # elevation but not distance. We have distance but not elevation.\n # We don't need to test if both are None because\n # we did that above.\n if elev_gain and distance :\n similarDF = actDF[ (actDF[dist_key] >= distance - dist_fudge*distance) & (actDF[dist_key] <= distance + dist_fudge*distance) & (actDF[elev_gain_key] >= elev_gain - elev_fudge*elev_gain) & (actDF[elev_gain_key] <= elev_gain + elev_fudge*elev_gain) ]\n print(\"\\nActivities with elevation gain similar to\", elev_gain, elev_units, \"and distance similar to\", distance, dist_units, \":\\n\")\n elif not distance :\n similarDF = actDF[ (actDF[elev_gain_key] >= elev_gain - elev_fudge*elev_gain) & (actDF[elev_gain_key] <= elev_gain + elev_fudge*elev_gain) ]\n print(\"Activities with elevation gain similar to\", elev_gain, elev_units, \":\")\n elif not elev_gain:\n similarDF = actDF[ (actDF[dist_key] >= distance - dist_fudge*distance) & (actDF[dist_key] <= distance + dist_fudge*distance) ]\n print(\"Activities with distance similar to\", distance, dist_units,\":\")\n\n list_of_urls = []\n if len(similarDF) > 0 :\n for i in similarDF.index:\n act_url = \"https://www.strava.com/activities/\" + str(i)\n # new\n if open_web :\n webbrowser.open_new_tab(act_url)\n list_of_urls.append(act_url)\n print(similarDF.loc[i, \"name\"], f'{similarDF.loc[i,dist_key]:.2f}', dist_units, f'{similarDF.loc[i,elev_gain_key]:.2f}', elev_units)\n print(act_url + \"\\n\")\n else:\n print(\"No activities with elevation gain similar to \", elev_gain, \"and distance similar to\", distance)\n return list_of_urls","def get_options_data(self, from_date, to_date, range=\"None\"):\n base_url = 'https://api.tdameritrade.com/v1/marketdata/chains?&symbol={stock_ticker}&fromDate={startdate}&toDate={enddate}&range={range}'\n endpoint = base_url.format(stock_ticker=self.ticker, startdate=from_date, enddate=to_date, range=range)\n\n page = requests.get(url=endpoint, params={'apikey': self.key})\n time.sleep(1)\n content = json.loads(page.content)\n\n call_options = pd.DataFrame()\n put_options = pd.DataFrame()\n\n if content[\"putExpDateMap\"] and content[\"callExpDateMap\"]:\n for date in content[\"callExpDateMap\"]:\n for strike in content[\"callExpDateMap\"][date]:\n for data in content[\"callExpDateMap\"][date][strike]:\n call_options = call_options.append({\n 'strikePrice': data[\"strikePrice\"],\n 'expirationDate': data[\"expirationDate\"],\n 'daysToExpiration': data[\"daysToExpiration\"],\n 'call': data[\"putCall\"],\n 'call_bid': data[\"bid\"],\n 'call_ask': data[\"ask\"],\n 'call_last': data[\"last\"],\n 'call_mark': data[\"mark\"],\n 'call_bidSize': data[\"bidSize\"],\n 'call_askSize': data[\"askSize\"],\n 'call_bidAskSize': data[\"bidAskSize\"],\n 'call_lastSize': data[\"lastSize\"],\n 'call_highPrice': data[\"highPrice\"],\n 'call_lowPrice': data[\"lowPrice\"],\n 'call_openPrice': data[\"openPrice\"],\n 'call_closePrice': data[\"closePrice\"],\n 'call_totalVolume': data[\"totalVolume\"],\n 'call_tradeDate': data[\"tradeDate\"],\n 'call_tradeTimeInLong': data[\"tradeTimeInLong\"],\n 'call_quoteTimeInLong': data[\"quoteTimeInLong\"],\n 'call_netChange': data[\"netChange\"],\n 'call_volatility': data[\"volatility\"],\n 'call_delta': data[\"delta\"],\n 'call_gamma': data[\"gamma\"],\n 'call_theta': data[\"theta\"],\n 'call_vega': data[\"vega\"],\n 'call_rho': data[\"rho\"],\n 'call_openInterest': data[\"openInterest\"],\n 'call_timeValue': data[\"timeValue\"],\n 'call_theoreticalOptionValue': data[\"theoreticalOptionValue\"],\n 'call_theoreticalVolatility': data[\"theoreticalVolatility\"],\n 'call_optionDeliverablesList': data[\"optionDeliverablesList\"],\n 'call_expirationType': data[\"expirationType\"],\n 'call_lastTradingDay': data[\"lastTradingDay\"],\n 'call_multiplier': data[\"multiplier\"],\n 'call_percentChange': data[\"percentChange\"],\n 'call_markChange': data[\"markChange\"],\n 'call_markPercentChange': data[\"markPercentChange\"]},\n ignore_index=True)\n\n for date in content[\"putExpDateMap\"]:\n for strike in content[\"putExpDateMap\"][date]:\n for data in content[\"putExpDateMap\"][date][strike]:\n put_options = put_options.append({\n 'strikePrice': data[\"strikePrice\"],\n 'expirationDate': data[\"expirationDate\"],\n 'daysToExpiration': data[\"daysToExpiration\"],\n 'put': data[\"putCall\"],\n 'put_bid': data[\"bid\"],\n 'put_ask': data[\"ask\"],\n 'put_last': data[\"last\"],\n 'put_mark': data[\"mark\"],\n 'put_bidSize': data[\"bidSize\"],\n 'put_askSize': data[\"askSize\"],\n 'put_bidAskSize': data[\"bidAskSize\"],\n 'put_lastSize': data[\"lastSize\"],\n 'put_highPrice': data[\"highPrice\"],\n 'put_lowPrice': data[\"lowPrice\"],\n 'put_openPrice': data[\"openPrice\"],\n 'put_closePrice': data[\"closePrice\"],\n 'put_totalVolume': data[\"totalVolume\"],\n 'put_tradeDate': data[\"tradeDate\"],\n 'put_tradeTimeInLong': data[\"tradeTimeInLong\"],\n 'put_quoteTimeInLong': data[\"quoteTimeInLong\"],\n 'put_netChange': data[\"netChange\"],\n 'put_volatility': data[\"volatility\"],\n 'put_delta': data[\"delta\"],\n 'put_gamma': data[\"gamma\"],\n 'put_theta': data[\"theta\"],\n 'put_vega': data[\"vega\"],\n 'put_rho': data[\"rho\"],\n 'put_openInterest': data[\"openInterest\"],\n 'put_timeValue': data[\"timeValue\"],\n 'put_theoreticalOptionValue': data[\"theoreticalOptionValue\"],\n 'put_theoreticalVolatility': data[\"theoreticalVolatility\"],\n 'put_optionDeliverablesList': data[\"optionDeliverablesList\"],\n 'put_expirationType': data[\"expirationType\"],\n 'put_lastTradingDay': data[\"lastTradingDay\"],\n 'put_multiplier': data[\"multiplier\"],\n 'put_percentChange': data[\"percentChange\"],\n 'put_markChange': data[\"markChange\"],\n 'put_markPercentChange': data[\"markPercentChange\"]},\n ignore_index=True)\n\n self.options_chain = pd.merge(call_options, put_options, how='outer', on=['strikePrice', 'expirationDate', 'daysToExpiration'], suffixes=(\"_call\", \"_put\"))\n self.options_chain['expirationDate'] = pd.to_datetime(self.options_chain['expirationDate'], unit = \"ms\")\n\n self.options_chain[\"call_put_volume\"] = self.options_chain[\"call_totalVolume\"] / self.options_chain[\"put_totalVolume\"]\n self.options_chain[\"call_put_oi\"] = self.options_chain[\"call_openInterest\"] / self.options_chain[\"put_openInterest\"]\n self.options_chain[\"call_volume_oi\"] = self.options_chain[\"call_totalVolume\"] / self.options_chain[\"call_openInterest\"]\n\n self.options_chain[\"put_call_volume\"] = self.options_chain[\"put_totalVolume\"] / self.options_chain[\"call_totalVolume\"]\n self.options_chain[\"put_call_oi\"] = self.options_chain[\"put_openInterest\"] / self.options_chain[\"call_openInterest\"]\n self.options_chain[\"put_volume_oi\"] = self.options_chain[\"put_totalVolume\"] / self.options_chain[\"put_openInterest\"]\n\n self.options_chain[\"ticker\"] = self.ticker\n\n self.options_chain = self.options_chain.replace(np.nan, 0)\n self.options_chain = self.options_chain.replace([np.inf, -np.inf], 999999)\n\n return self.options_chain\n\n else:\n return call_options","def test_get_offers(self):\n pass","def get_queryset(self):\n as_of = date.today()\n\n result = ExpectedUse.objects.filter(\n Q(expiration_date__gte=as_of) | Q(expiration_date=None)\n ).order_by('display_order')\n result = result.filter(\n effective_date__lte=as_of\n ).order_by('display_order')\n\n return result","def resolve_params(self) -> List[WhereType]:\n conditions = []\n\n # Update start to be within retention\n expired = False\n if self.start and self.end:\n expired, self.start = outside_retention_with_modified_start(\n self.start, self.end, self.params.organization\n )\n\n if expired:\n raise QueryOutsideRetentionError(\n \"Invalid date range. Please try a more recent date range.\"\n )\n\n if self.start:\n conditions.append(Condition(self.column(\"timestamp\"), Op.GTE, self.start))\n if self.end:\n conditions.append(Condition(self.column(\"timestamp\"), Op.LT, self.end))\n\n conditions.append(\n Condition(\n self.column(\"project_id\"),\n Op.IN,\n self.params.project_ids,\n )\n )\n\n if len(self.params.environments) > 0:\n term = event_search.SearchFilter(\n event_search.SearchKey(\"environment\"),\n \"=\",\n event_search.SearchValue(self.params.environment_names),\n )\n condition = self._environment_filter_converter(term)\n if condition:\n conditions.append(condition)\n\n if self.requires_organization_condition:\n if self.params.organization is None:\n raise InvalidSearchQuery(\"Organization is a required parameter\")\n\n conditions.append(\n Condition(\n self.column(self.organization_column),\n Op.EQ,\n self.params.organization.id,\n )\n )\n\n return conditions","def append_new_offers(old_offers, new_offers):\n return [{'offers': new_offers, 'added_at': datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}, *old_offers]","def solve_filter_metrics(self):\n\n if 'metrics' in self.filter_request:\n filter_metrics = self.filter_request['metrics']\n metrics_request = {}\n\n temp = filter_metrics.split(',')\n for i in temp:\n metrics_request[i.strip()] = None\n\n for i in range(len(self.list_pack)):\n self.apply_filter_metrics(i, metrics_request.copy())","def test_magnitude_filters(self):\n credentials = Mock(base_url=\"\")\n\n manager = Manager('invoices', credentials)\n uri, params, method, body, headers, singleobject = manager._filter(**{'Date__gt': datetime.datetime(2007, 12, 6)})\n\n self.assertEqual(\n params,\n {u'where': u'Date>DateTime(2007,12,6)'}\n )\n\n manager = Manager('invoices', credentials)\n uri, params, method, body, headers, singleobject = manager._filter(**{'Date__lte': datetime.datetime(2007, 12, 6)})\n\n self.assertEqual(\n params,\n {u'where': u'Date<=DateTime(2007,12,6)'}\n )","def queryset(self, request, queryset):\n # Compare the requested value (either '80s' or '90s')\n # to decide how to filter the queryset.\n\n if self.value() == 'passed':\n return queryset.filter(renewal_date__lt=datetime.datetime.now())\n if self.value() == 'today':\n return queryset.filter(renewal_date__gte=datetime.datetime.now(),\n renewal_date__lte=datetime.datetime.now() + datetime.timedelta(days=1))\n if self.value() == 'week':\n return queryset.filter(renewal_date__gte=datetime.datetime.now() + datetime.timedelta(days=1),\n renewal_date__lte=datetime.datetime.now() + datetime.timedelta(days=7))\n if self.value() == 'month':\n return queryset.filter(renewal_date__gte=datetime.datetime.now() + datetime.timedelta(days=7),\n renewal_date__lte=datetime.datetime.now() + datetime.timedelta(days=31))","def __getQuerysetGivenInterval(model, start_date, end_date):\n cur_model = {\n 'donor': Donor,\n 'donation': Donation,\n 'item': Item\n }.get(model, Donor.objects.none())\n\n # might need following lines when changing back to created_at:\n # date_format = \"%Y-%m-%d\"\n # if start_date is not None:\n # timezone_unaware_start_date = datetime.strptime(start_date, date_format)\n # timezone_aware_start_date = pytz.utc.localize(timezone_unaware_start_date)\n #\n # if end_date is not None:\n # timezone_unaware_end_date = datetime.strptime(end_date, date_format)\n # timezone_aware_end_date = pytz.utc.localize(timezone_unaware_end_date).date()\n\n if start_date is not None and end_date is not None:\n return cur_model.objects.filter(documented_at__range=(start_date, end_date))\n elif start_date is not None and end_date is None:\n return cur_model.objects.filter(documented_at__gte=start_date)\n elif start_date is None and end_date is not None:\n return cur_model.objects.filter(documented_at__lte=end_date)\n else:\n return cur_model.objects.all()","def _process_alert_source_filters(query, filters):\n if filters:\n if not is_valid_model_filters(models.AlertSource, filters):\n return\n query = query.filter_by(**filters)\n\n return query","def get_queryset(self):\n \n queryset = queryset = Row.objects.filter(status_active = 1 )\n\n # se obtienen queryset del request\n dataset_id = self.request.query_params.get('dataset_id', None)\n name_dataset = self.request.query_params.get('name', None)\n point = self.request.query_params.get('point', None)\n \n # se generan las diferentes combinaciones para que los queryset no sea \n # obligatorios sino que estos sean opcionales\n\n if (dataset_id is not None) and (name_dataset is not None) and (point is not None):\n print(\"entro a point \")\n queryset = queryset.filter( point = point , dataset_id = dataset_id, dataset_id__name = \"\"+(name_dataset))\n return queryset\n\n elif (dataset_id is not None) and (name_dataset is not None):\n queryset = queryset.filter(dataset_id = dataset_id, dataset_id__name = \"\"+(name_dataset))\n return queryset\n \n elif (dataset_id is not None) and (point is not None):\n queryset = queryset.filter(dataset_id = dataset_id, point = point )\n return queryset\n\n elif (name_dataset is not None) and (point is not None):\n queryset = queryset.filter(dataset_id__name = \"\"+(name_dataset) , point = point )\n return queryset\n\n\n if name_dataset is not None:\n queryset = queryset.filter(dataset_id__name = \"\"+(name_dataset) )\n return queryset\n\n elif dataset_id is not None:\n queryset = queryset.filter(dataset_id = dataset_id)\n return queryset\n\n elif point is not None:\n queryset = queryset.filter(point = point)\n return queryset\n else:\n return queryset","def _boundary_filter(self, south, west, north, east):\n return Q(latitude__gt=south, longitude__gt=west, \n latitude__lt=north, longitude__lt=east)","def filter_by_query(x, _query=None):\n if _query:\n scores = [fuzz.partial_ratio(_query, \"{0} {1}\".format(x[\"requester\"][\"first_name\"], x[\"requester\"][\"last_name\"])),\n fuzz.partial_ratio(_query, x[\"requester\"][\"email\"]),\n fuzz.partial_ratio(_query, x[\"requester\"][\"net_id\"]),\n fuzz.partial_ratio(_query, x[\"pay_to\"][\"name\"]),\n fuzz.partial_ratio(_query, x[\"pay_to\"][\"email\"]),\n fuzz.partial_ratio(_query, x[\"pay_to\"][\"id\"] or \"\"),\n fuzz.partial_ratio(_query, x[\"short_description\"]),\n fuzz.partial_ratio(_query, x[\"notes\"])]\n\n if max(scores) > 60:\n return True\n return False\n return True","def get_events(start, end, filters=None):\n\n from frappe.desk.calendar import get_event_conditions\n conditions = get_event_conditions('Booking Request', filters)\n\n data = frappe.db.sql(\"\"\"\n SELECT\n `tabBooking Request`.name, `tabBooking Request`.eta_date,\n `tabBooking Request`.etd_date, `tabBooking Request`.status, `tabBooking Request Status`.color\n FROM\n `tabBooking Request`\n LEFT JOIN `tabBooking Request Status` ON `tabBooking Request`.status = `tabBooking Request Status`.name\n WHERE\n (`tabBooking Request`.docstatus < 2)\"\"\", as_dict=True)\n\n return data","def _filter(self, location, component=\"Hosting\", compute_type=None):\n filters = [\n [\"TERM_MATCH\", \"location\", location],\n [\"TERM_MATCH\", \"productFamily\", \"ML Instance\"],\n [\"TERM_MATCH\", \"currentGeneration\", \"Yes\"],\n [\"TERM_MATCH\", \"component\", component]\n ]\n if compute_type:\n filters.append([\"TERM_MATCH\", \"computeType\", compute_type])\n return [{\n 'Type': x[0],\n 'Field': x[1],\n 'Value': x[2]\n } for x in filters]","def search2(term, location, distance):\n\n print location\n if float(distance) <= 5.0:\n radius = 0.75\n elif float(distance) > 5.0 and float(distance) <= 10.0:\n radius = 1.5\n elif float(distance) > 10.0 and float(distance) <= 25.0:\n radius = 4\n elif float(distance) > 25.0 and float(distance) <= 100.0:\n radius = 8\n elif float(distance) > 100.0:\n radius = 15\n\n metradius = int(float(1609) * float(radius))\n print metradius\n url_params = {\n 'category_filter': term.replace(' ', '+'),\n 'radius_filter': metradius,\n 'll': location.replace(' ', '+'),\n 'limit': SEARCH_LIMIT\n }\n return request(API_HOST, SEARCH_PATH, url_params=url_params)","def step_filter(self, qs):\n return qs","def get_queryset(self):\n\t\treturn EffortInstance.objects.order_by('-date_start')[:15]","def queryset(self, request):\n qs = super(AdRepAdvertiserAdmin, self).queryset(request)\n qs = AdRepAdvertiser.objects.select_related().filter(id__in=qs\n ).defer('advertiser__site__envelope',\n 'advertiser__site__geom',\n 'advertiser__site__point')\n return qs","def get_queryset(self):\n\n if self.request.user.is_staff:\n queryset = Retreat.objects.all()\n else:\n queryset = Retreat.objects.filter(\n is_active=True,\n hidden=False\n )\n queryset = queryset.filter(hide_from_client_admin_panel=False)\n\n queryset = queryset.annotate(\n max_end_date=Max('retreat_dates__end_time'),\n min_start_date=Min('retreat_dates__start_time'),\n )\n\n # Filter by display_start_time lower than\n display_start_time_lte = self.request.query_params.get(\n 'display_start_time_lte',\n None,\n )\n if display_start_time_lte:\n queryset = queryset.filter(\n display_start_time__lte=display_start_time_lte\n )\n\n # Filter by display_start_time greater than\n display_start_time_gte = self.request.query_params.get(\n 'display_start_time_gte',\n None,\n )\n if display_start_time_gte:\n queryset = queryset.filter(\n display_start_time__gte=display_start_time_gte\n )\n return queryset","def prepare_amazon_request_report_kwargs(self, seller):\n account = self.env['iap.account'].search([('service_name', '=', 'amazon_ept')])\n dbuuid = self.env['ir.config_parameter'].sudo().get_param('database.uuid')\n instances_obj = self.env['amazon.instance.ept']\n instances = instances_obj.search([('seller_id', '=', seller.id)])\n marketplaceids = tuple(map(lambda x: x.market_place_id, instances))\n\n return {'merchant_id': seller.merchant_id and str(seller.merchant_id) or False,\n 'auth_token': seller.auth_token and str(seller.auth_token) or False,\n 'app_name': 'amazon_ept',\n 'account_token': account.account_token,\n 'dbuuid': dbuuid,\n 'amazon_marketplace_code': seller.country_id.amazon_marketplace_code or\n seller.country_id.code,\n 'marketplaceids': marketplaceids,\n }","def test_adding_criteria_to_segments(self):\n pass","def filter_plot(mode, country, continent, start_date, end_date, options):\n # Default is World mode\n chart_data = world_daywise_df\n map_data = countries_daywise_df\n print(country, continent)\n if mode == SelectionMode.Continents.value:\n #Continents mode\n if not isinstance(continent, list):\n continent = [continent]\n\n chart_data = continents_daywise_df[continents_daywise_df['WHO Region'].isin(continent)]\n map_data = map_data[map_data['WHO Region'].isin(continent)]\n elif mode == SelectionMode.Countries.value:\n # Countries mode\n if not isinstance(country, list):\n country = [country]\n\n chart_data = countries_daywise_df[countries_daywise_df['Country/Region'].isin(country)]\n map_data = chart_data\n\n chart_data = chart_data.query('Date >= @start_date & Date <= @end_date')\n map_data = map_data.query('Date >= @start_date & Date <= @end_date')\n\n # fix error when groupby geometry or put it in the aggregate column\n temp = map_data.drop(['geometry', 'country_code', 'Date'], axis=1).groupby(['Country/Region']).agg(metrics).reset_index()\n map_data = join_country_code_data(temp, country_code_data)\n\n if is_perCapita(options):\n for metric in ['Confirmed', 'Deaths', 'Recovered']:\n chart_data[metric + '_per_capita'] = chart_data[metric] / chart_data['Population']\n map_data[metric + '_per_capita'] = map_data[metric] / map_data['Population']\n \n if is_perCapita(options):\n return plot(chart_data, 'Confirmed_per_capita', 'Confirmed Cases Per Capita'), \\\n plot(chart_data, 'Deaths_per_capita', 'Confirmed Deaths Per Capita'), \\\n plot(chart_data, 'Recovered_per_capita', 'Confirmed Recoveries Per Capita'), \\\n generate_map(map_data)\n\n return plot(chart_data, 'Confirmed', 'Confirmed Cases'), \\\n plot(chart_data, 'Deaths', 'Confirmed Deaths'), \\\n plot(chart_data, 'Recovered', 'Confirmed Recoveries'), \\\n generate_map(map_data)","def get_features_near_me(self,collection,point,radius,earth_radius=3963.2): #km = 6371\n x,y = point\n res = self.client['rephie'][collection].find( { 'geometry': { '$geoWithin': { '$centerSphere': [ [x, y ] , radius/earth_radius ] } }} )\n \n return self._make_result_list(res)","def filter_data(df, coords, vel=False, vel_threshold=0.15, radiant_threshold=5):\n\tdf = df[(df.range > 110) & (df.range < 130) \n\t\t& (df.th < 70) # Unphysical, given the range cut.\n\t\t& (df.fl == 0)] # Bad interferometry if fl=1\n\n\t# Velocity cut\n\tif vel:\n\t\tdf = df[(df.new_ptn > vel*(1-vel_threshold)) \n\t\t& (df.new_ptn < vel*(1+vel_threshold))]\n\n\t# Identify the shower radiant\n\tif isinstance(coords, str):\n\t\twavelet = read_wavelet(coords)\n\t\tdf = df.apply(get_wavelet_radiant, axis=1, args=(wavelet,))\n\telse:\n\t\tdf['radiant_ll0'] = coords[0]\n\t\tdf['radiant_beta'] = coords[1]\n\n\tdf['separation'] = df.apply(check_radiant, axis=1)\n\tdf.drop(['radiant_ll0', 'radiant_beta'], axis=1, inplace=True)\n\tdf_shower = df[df['separation'] <= radiant_threshold]\n\treturn df_shower","def person_search_qs(request):\n query = request.GET\n qs = Person.objects.filter(expiry_date__gt=timezone.now())\n\n # base registration and application querysets\n registrations_qs = Register.objects.all()\n applications_qs = RegistriesApplication.objects.all()\n\n person_filters = Q()\n reg_filters = Q()\n appl_filters = Q()\n\n\n # Search for cities (split list and return all matches)\n # search comes in as a comma-separated querystring param e.g: ?city=Atlin,Lake Windermere,Duncan\n cities = query.get('city', None)\n if cities:\n cities = cities.split(',')\n person_filters = person_filters & Q(registrations__organization__city__in=cities)\n reg_filters = reg_filters & Q(organization__city__in=cities)\n \n # regional areas\n region_guids = query.get('region', None)\n if region_guids:\n region_guids = region_guids.split(',')\n regional_areas = RegionalArea.objects.filter(regional_area_guid__in=region_guids)\n person_filters &= Q(registrations__organization__regional_areas__in=regional_areas)\n reg_filters &= Q(organization__regional_areas__in=regional_areas)\n\n #bbox\n sw_long = query.get('sw_long')\n sw_lat = query.get('sw_lat')\n ne_long = query.get('ne_long')\n ne_lat = query.get('ne_lat')\n if sw_long and sw_lat and ne_long and ne_lat:\n try:\n bbox = Polygon.from_bbox((sw_long, sw_lat, ne_long, ne_lat))\n bbox.srid = 4326\n person_filters = person_filters & Q(registrations__organization__geom__bboverlaps=bbox)\n reg_filters = reg_filters & Q(organization__geom__bboverlaps=bbox)\n except (ValueError, GEOSException):\n pass\n\n #Subactivities param comes as a csv list\n subactivities = query.get('subactivities')\n if subactivities is not None: \n subactivities = subactivities.split(\",\")\n person_filters = person_filters & \\\n Q(registrations__applications__subactivity__registries_subactivity_code__in=subactivities)\n reg_filters = reg_filters & \\\n Q(applications__subactivity__registries_subactivity_code__in=subactivities)\n appl_filters = appl_filters & \\\n Q(subactivity__registries_subactivity_code__in=subactivities)\n\n activity = query.get('activity', None)\n status = query.get('status', None)\n user_is_staff = request.user.groups.filter(name=REGISTRIES_VIEWER_ROLE).exists()\n\n if activity:\n if (status == 'P' or not status) and user_is_staff:\n # We only allow staff to filter on status\n # For pending, or all, we also return search where there is no registration.\n person_filters = person_filters & \\\n (\n Q(registrations__registries_activity__registries_activity_code=activity) |\n Q(registrations__isnull=True)\n )\n reg_filters = reg_filters & \\\n Q(registries_activity__registries_activity_code=activity)\n else:\n # For all other searches, we strictly filter on activity.\n person_filters = person_filters & \\\n Q(registrations__registries_activity__registries_activity_code=activity)\n reg_filters = reg_filters & \\\n Q(registries_activity__registries_activity_code=activity)\n\n if user_is_staff:\n # User is logged in\n if status:\n if status == 'Removed':\n # Things are a bit more complicated if we're looking for removed, as the current\n # status doesn't come in to play.\n person_filters = person_filters & \\\n Q(registrations__applications__removal_date__isnull=False)\n reg_filters = reg_filters & \\\n Q(applications__removal_date__isnull=False)\n appl_filters = appl_filters & \\\n Q(removal_date__isnull=False)\n else:\n if status == 'P':\n # If the status is pending, we also pull in any people without registrations\n # or applications.\n person_filters = person_filters & \\\n (\n Q(registrations__applications__current_status__code=status) |\n Q(registrations__isnull=True) |\n Q(registrations__applications__isnull=True) \n ) & \\\n Q(registrations__applications__removal_date__isnull=True)\n reg_filters = reg_filters & \\\n (\n Q(applications__current_status__code=status) | \n Q(applications__isnull=True) \n ) & \\\n Q(applications__removal_date__isnull=True) \n appl_filters = appl_filters & \\\n (\n Q(current_status__code=status) \n #Q(isnull=True) \n ) & \\\n Q(removal_date__isnull=True) \n else:\n person_filters = person_filters & \\\n (\n Q(registrations__applications__current_status__code=status) &\n Q(registrations__applications__removal_date__isnull=True)\n )\n reg_filters = reg_filters & \\\n (\n Q(applications__current_status__code=status) &\n Q(applications__removal_date__isnull=True)\n )\n appl_filters = appl_filters & \\\n (\n Q(current_status__code=status) &\n Q(removal_date__isnull=True)\n )\n else:\n # User is not logged in\n # Only show active drillers to non-admin users and public\n person_filters = person_filters & \\\n (\n Q(registrations__applications__current_status__code='A') &\n Q(registrations__applications__removal_date__isnull=True)\n )\n\n reg_filters = reg_filters & \\\n (\n Q(applications__current_status__code='A') &\n Q(applications__removal_date__isnull=True)\n )\n appl_filters= appl_filters & \\\n (\n Q(current_status='A') & \n Q(removal_date__isnull=True)\n )\n\n #apply all the \"main\" and \"registration\" filters that were chosen above\n qs = qs.filter(person_filters)\n registrations_qs = registrations_qs.filter(reg_filters)\n applications_qs = applications_qs.filter(appl_filters)\n\n\n # generate applications queryset\n applications_qs = applications_qs \\\n .select_related(\n 'current_status',\n 'primary_certificate',\n 'primary_certificate__cert_auth',\n 'subactivity',\n ) \\\n .prefetch_related(\n 'subactivity__qualification_set',\n 'subactivity__qualification_set__well_class'\n ).distinct() \n\n # generate registrations queryset, inserting filtered applications queryset defined above\n registrations_qs = registrations_qs \\\n .select_related(\n 'registries_activity',\n 'organization',\n 'organization__province_state',\n ) \\\n .prefetch_related(\n Prefetch('applications', queryset=applications_qs)\n ).distinct() \n\n # insert filtered registrations set\n qs = qs \\\n .prefetch_related(\n Prefetch('registrations', queryset=registrations_qs)\n )\n\n return qs.distinct()","def calculate_event_price_and_parameters(self, event_id):\n try:\n price = 0\n proffesional_staff = 0\n middle_staff = 0\n new_staff = 0\n\n req_id, _, client_id, title, location, date_starts, date_ends, guests, event_type_id, event_class_id, _ = self.db_handler.get_event_request_extended_info_by_id(event_id)\n _, event_class_name, guests_per_waiter = self.db_handler.get_event_class_by_id(event_class_id)\n\n distance_in_km = self.get_geopy_distance(location)\n price = distance_in_km * float(self.get_config_value('PRICE_OF_KM'))\n num_of_staff = math.ceil(guests / guests_per_waiter)\n\n if event_class_name == 'Найвищий': #85% of pro\n new_staff = 0\n proffesional_staff = math.ceil(num_of_staff * 0.85)\n middle_staff = num_of_staff - proffesional_staff\n elif event_class_name == 'Високий': #75% of pro\n new_staff = 0\n proffesional_staff = math.ceil(num_of_staff * 0.75)\n middle_staff = num_of_staff - proffesional_staff\n elif event_class_name == 'Середній':\n new_staff = round(num_of_staff * 0.2)\n middle_staff = num_of_staff - new_staff\n elif event_class_name == 'Початковий':\n middle_staff = math.ceil(num_of_staff * 0.3)\n new_staff = round(num_of_staff - middle_staff)\n\n hours_of_shift = (date_ends - date_starts).seconds / 3600\n\n price += proffesional_staff * float(self.get_config_value('PRO_RATE')) * hours_of_shift\n price += middle_staff * float(self.get_config_value('MID_RATE')) * hours_of_shift\n price += new_staff * float(self.get_config_value('NEW_RATE')) * hours_of_shift\n\n price += price * 0.4\n\n return (price,proffesional_staff,middle_staff,new_staff)\n except Exception as err:\n method_name = sys._getframe().f_code.co_name\n\n self.logger.write_to_log('exception', 'model')\n self.logger.write_to_err_log(f'exception in method {method_name} - {err}', 'model')","def get(self, request):\n TODOs = Todotbl.objects.all() if request.user.role == User.ADMIN else Todotbl.objects.filter(user=request.user)\n for filterData in re.split(Filter.separator, request.data[Filter.column]):\n filterDataMake = FilterData()\n # set column to search\n if Filter.column_priority in filterData:\n filterDataMake.columnName = Filter.column_priority\n elif Filter.column_status in filterData:\n filterDataMake.columnName = Filter.column_status\n\n # what search (order by or filtering)\n if Filter.asc in filterData: # order by asc\n filterDataMake.val = Filter.asc\n TODOs = Todotbl.objects.filter(id__in=TODOs).order_by(filterDataMake.columnName).distinct()\n elif Filter.desc in filterData: # order by desc\n filterDataMake.val = Filter.desc\n TODOs = Todotbl.objects.filter(id__in=TODOs).order_by(filterDataMake.columnName).reverse().distinct()\n else:\n if Filter.more in filterData: # if more\n filterDataMake.isMore = True\n elif Filter.less in filterData: # if less\n filterDataMake.isLess = True\n\n if Filter.equal in filterData: # if equal\n filterDataMake.isEqual = True\n if filterDataMake.isMore: # if more equal\n if Filter.column_priority == filterDataMake.columnName: # if more equal in column priority\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n priority__gte=validate_priority(filterData)).distinct()\n elif Filter.column_status == filterDataMake.columnName: # if more equal in column status\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n status__gte=validate_word_status(filterData, '>=')) \\\n .distinct()\n elif filterDataMake.isLess: # if less equal\n if Filter.column_priority == filterDataMake.columnName: # if less equal in column priority\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n priority__lte=validate_priority(filterData)).distinct()\n elif Filter.column_status == filterDataMake.columnName: # if less equal in column status\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n status__lte=validate_word_status(filterData,\n '<=')).distinct()\n else: # if equal\n if Filter.column_priority == filterDataMake.columnName: # if equal in column priority\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n priority=validate_priority(filterData)).distinct()\n elif Filter.column_status == filterDataMake.columnName: # if equal in column status\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n status=validate_word_status(filterData, '=')).distinct()\n\n else: # if not equal, only more or less\n if filterDataMake.isMore: # if more\n if Filter.column_priority == filterDataMake.columnName: # if more in column priority\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n priority__gt=validate_priority(filterData)).distinct()\n elif Filter.column_status == filterDataMake.columnName: # if more in column status\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n status__gt=validate_word_status(filterData, '>')).distinct()\n else: # if less\n if Filter.column_priority == filterDataMake.columnName: # if less in column priority\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n priority__lt=validate_priority(filterData)).distinct()\n elif Filter.column_status == filterDataMake.columnName: # if less in column status\n TODOs = Todotbl.objects.filter(id__in=TODOs,\n status__lt=validate_word_status(filterData, '<')).distinct()\n return Response((model_to_dict(TODO) for TODO in TODOs), status=status.HTTP_200_OK)","def _filter_by_date(from_date, until_date):\n qlist = []\n\n if from_date:\n qlist.append(Q(oai_date_stamp__gte=from_date))\n\n if until_date:\n qlist.append(Q(oai_date_stamp__lte=until_date))\n\n return qlist","def df_effective_sale(start=None, end=None, f=None, all=False):\n df = DataFrame(columns=['efectivas'])\n \n def is_effective(row):\n if row[1].startswith('gestion 3') and row[0] >= 14:\n return True\n elif row[1].startswith('gestion') and row[0] >= 7:\n return True\n elif ~row[1].startswith('gestion') and row[0] > 0:\n return True\n else:\n return False\n\n hits = search_sale_values(start, end, f)\n\n obj = {}\n\n for hit in hits:\n if hit.type in SALE_VALUES:\n task_id = hit.task_id\n amount = SALE_VALUES.get(hit.type, 0)\n obj[task_id] = obj.get(task_id, 0) + amount\n\n if obj == {}:\n df.loc['total'] = df.sum()\n return df.astype('int64')\n\n df_sv = DataFrame.from_dict(obj, orient='index')\n df_sv.index.name = 'task_id'\n\n hits = search_sale_tasks(start, end, f)\n\n obj = { hit.task_id: hit.remarks for hit in hits }\n\n if obj == {}:\n df.loc['total'] = df.sum()\n return df.astype('int64')\n\n df_g = DataFrame.from_dict(obj, orient='index')\n df_g.index.name = 'task_id'\n\n df = df_sv.merge(df_g, on='task_id', how='inner')\n df['effective'] = df.apply(is_effective, axis=1)\n df = df.drop('0_x', axis=1).groupby('0_y').sum()\n\n obj = {}\n\n for remark in df.index.tolist():\n if (\n remark.startswith('gestion') or\n remark.startswith('gestion 2') or\n remark.startswith('gestion 3')\n ):\n tipo = 'gestión'\n elif remark.startswith('ticket'):\n tipo = 'ticket'\n elif remark.startswith('verificacion'):\n tipo = 'verificación'\n elif remark.startswith('tendero venta'):\n tipo = 'tendero Venta'\n elif remark.startswith('tendero sync'):\n tipo = 'tendero Sync'\n elif remark.startswith('kingo basico'):\n tipo = 'swap k7 o venta >= 1 semana'\n elif remark.startswith('kingo tv'):\n tipo = 'swap a kingo tv'\n elif (\n remark.startswith('tecnica') or\n remark.startswith('promocion precio') or\n remark.startswith('corregir') or\n remark.startswith('cliente activo') or\n remark.startswith('asignacion especial tecnica')\n ):\n tipo = 'técnica'\n elif (\n remark.startswith('preventa kingo tv') or\n remark.startswith('preventa: k15 tv') or\n remark.startswith('preventa: kingo tv')\n ):\n tipo = 'Preventa Kingo TV'\n elif remark.startswith('preventa kingo hogar'):\n tipo = 'Preventa Kingo Hogar'\n else:\n tipo = 'sin tipo'\n obj[tipo] = obj.get(tipo, 0) + df.at[remark, 'effective']\n\n df = DataFrame.from_dict(obj, orient='index', columns=['efectivas'])\n df = df.astype('int64').sort_index()\n\n if not all and 'sin tipo' in df.index:\n df = df.drop('sin tipo')\n\n df.loc['total'] = df.sum()\n df.index.name = 'tipo de tarea'\n\n return df","def _get_endpoint_list(name, filter_by, limit, offset, quiet, all_items):\n\n get_endpoint_list(name, filter_by, limit, offset, quiet, all_items)","def execute_search(locations, distance, query):\n full_business_list = []\n for engine in [google, yelp]:\n businesses = []\n for lat, lng in locations:\n businesses.extend(engine.search(lat, lng, distance, query))\n # Remove duplicates from API call overlap\n names = set()\n filtered_list = []\n print(time.strftime(\"%Y/%m/%d at %H:%M:%S \") + engine.__name__ + \" \" + str(len(businesses)))\n for business in businesses:\n if business:\n filtered_list.append(business)\n names.add(business.name)\n businesses = filtered_list\n # Calculate low threshold and average ratings\n try:\n low_threshold = min(\n business.rating_count for business in businesses)\n except:\n # go to next item\n continue\n average_rating = sum(\n business.rating for business in businesses) / len(businesses)\n # Convert to 10 point scale\n scale_multiplier = 2\n # Add bayesian estimates to business objects\n for business in businesses:\n business.bayesian = bayesian(business.rating * scale_multiplier,\n business.rating_count,\n low_threshold,\n average_rating * scale_multiplier)\n\n # Add this search engine's list to full business list\n full_business_list.extend(businesses)\n\n return full_business_list","def get_filtered(self, collection, xmlFormat):\n\t\tstart = \"2012-05-01T00:00:00Z\"\n\t\tend = \"2012-05-20T00:00:00Z\"\n\t\tquery = '/text//annotationRecord/service/date/@modified:[%s TO %s]' % (start, end)\n\t\t\n\t\treturn {\n\t\t\t'q' : query,\n\t\t\t\"verb\": \"Search\",\n\t\t\t\"xmlFormat\": xmlFormat,\n\t\t\t\"ky\": collection,\n\t\t\t'sortDescending' : '/text//annotationRecord/service/date/@modified'\n\t\t\t}","def _parse_optimizer_params(self, params):\n i = 0\n for filt in self.filters:\n if filt.optimize_fc:\n filt.fc = 10 ** params[i]\n i += 1\n if filt.optimize_q:\n filt.q = params[i]\n i += 1\n if filt.optimize_gain:\n filt.gain = params[i]\n i += 1","def filter_criteria_met(current_gre, current_gpa, current_toefl):\r\n\r\n if int(current_gre) < global_constants['MINIMUM_GRE']:\r\n return False\r\n if float(current_gpa) < global_constants['MINIMUM_GPA']:\r\n return False\r\n if int(current_toefl) < global_constants['MINIMUM_TOEFL']:\r\n return False\r\n return True","def build_query_structure(self):\n query_list = list()\n filter_list = list()\n for key, val in self.q_dict.items():\n if key in self.es_query_keys:\n query_list.append(\n {\"match\": {\".\".join(key.split(\"_\")): val[0]}})\n elif key in self.es_date_keys:\n filter_list.append(\n {\"range\": {\".\".join(key.split(\"_\")): val}})\n elif \":\" in val[0]:\n #for handling queries like dd_dct=gte:1\n range_val = val[0].split(\":\")\n filter_list.append({\"range\": {\".\".join(key.split(\"_\")): {\n range_val[0]: int(range_val[1])}}})\n else:\n filter_list.append(\n {\"terms\": {\".\".join(key.split(\"_\")): val}})\n return query_list, filter_list","def default_filters(self, query) -> object:\n user = self.request.user\n model = self.model\n custom_filter = self.request.params.get('_custom_filter')\n if 'g:professionals' in user.groups and custom_filter == 'pool':\n # disable security for this custom filter\n self.enable_security = False\n professional = Professional.get(user.id)\n pool_ids = [item.id for item in professional.pools]\n query = query.filter(\n model.pool_id.in_(pool_ids),\n model.state == 'published'\n )\n elif custom_filter == 'late_first_submission':\n config_delta = timedelta(seconds=int(LATE_SUBMISSION_SECONDS))\n date_limit = datetime_utcnow() - config_delta\n query = query.filter(\n model.scheduled_datetime <= date_limit,\n model.state == 'awaiting_assets',\n model.last_approval_date.is_(None)\n )\n elif custom_filter == 'late_re_submission':\n config_delta = timedelta(seconds=int(LATE_SUBMISSION_SECONDS))\n date_limit = datetime_utcnow() - config_delta\n query = query.filter(\n model.last_approval_date <= date_limit,\n model.state == 'awaiting_assets',\n model.submission_path.isnot(None),\n )\n return query","def get_queryset(self):\n\n circle = self.circle\n\n if self.action not in ['finish', 'qualify']:\n offset = timezone.now() + timedelta(minutes=10)\n\n queryset = circle.ride_set.filter(\n available_seats__gte=1,\n departure_date__gte=offset\n )\n else:\n queryset = circle.ride_set.all()\n\n return queryset","def _get_applicable_offers(self, current_protocol, path):\n\n edges = []\n\n for from_protocol_name, offers in self._adaptation_offers.items():\n from_protocol = offers[0].from_protocol\n mro_distance = self.mro_distance_to_protocol(\n current_protocol, from_protocol\n )\n\n if mro_distance is not None:\n\n for offer in offers:\n # Avoid cycles by checking that we did not consider this\n # offer in this path.\n if offer not in path:\n edges.append((mro_distance, offer))\n\n return edges","def filter_by_query_params(self, request):\n items = self\n project = request.GET.get('project', None)\n customer = request.GET.get('customer', None)\n company = request.GET.get('company', None)\n engineer = request.GET.get('engineer', None)\n q = request.GET.get('q', None)\n sort_by = request.GET.get('sort_by', None)\n str = request.GET.get('str', None)\n\n if project:\n items = items.filter(project=project).distinct()\n if engineer:\n items = items.filter(lead__sales_engineer=engineer).distinct()\n if customer:\n items = items.filter(lead__customer=customer).distinct()\n if company:\n items = items.filter(company=company).distinct()\n # sort\n if q == 'asc' and sort_by:\n items = items.order_by(sort_by).distinct()\n\n if q == 'des' and sort_by:\n items = items.order_by('-' + sort_by).distinct()\n\n if str:\n # str = str.strip().lower()\n items = items.filter(Q(reference_no__icontains=str) |\n Q(erp_reference__icontains=str)).distinct()\n return items","def get_filters():\n print('Hello! Let\\'s explore some US bikeshare data!')","def get_active_features(summary_df, slots_offered): # prev -> getActiveFeatures\n disc_cols = [col+'_Discount' for col in slots_offered]\n eco_cols = [col+'_Eco' for col in slots_offered]\n gr_cols = [col+'_Eco' for col in slots_offered]\n features = summary_df.loc[:, disc_cols+eco_cols+gr_cols]\n features = features.loc[:, features.sum(axis=0) > 0]\n for i in reversed(['NO_PURCHASE']+slots_offered):\n features.insert(0, i+'_Asc', value=1)\n return features, disc_cols, eco_cols, gr_cols","def nearby(point, radius, unit):\n qs = MyModel.objects.all()\n qs = qs.filter(point__distance_lte=(point, D(**{unit: radius})))\n qs = qs.distance(point) # at this point, the type of queryset is GeoQuerySet\n qs = qs.order_by('distance')\n return qs"],"string":"[\n \"def _compute_offers_to_send(self) -> Dict[Tuple[float, float], float]:\\n partial_asgt = self._neighbors_values.copy()\\n offers = dict()\\n\\n for limited_asgt in generate_assignment_as_dict([self.variable, self._partner]):\\n partial_asgt.update(limited_asgt)\\n cost = self._compute_cost(**partial_asgt)\\n if self.logger.isEnabledFor(logging.DEBUG):\\n self.logger.debug(\\n f\\\"looking for offer : {partial_asgt} - cost {cost}\\\"\\n f\\\" current {self.current_cost} {self._mode}\\\"\\n )\\n\\n if (self.current_cost > cost and self._mode == \\\"min\\\") or (\\n self.current_cost < cost and self._mode == \\\"max\\\"\\n ):\\n offers[(limited_asgt[self.name], limited_asgt[self._partner.name])] = (\\n self.current_cost - cost\\n )\\n return offers\",\n \"def filterEvents(intervals_dates,list_infected,distance):\\n d=distance\\n list_gpsevents=[]\\n for z in range(len(intervals_dates)-1):\\n print(\\\"Interval: \\\",intervals_dates[z], \\\"y\\\", intervals_dates[z+1])\\n infected,uninfected=getTrazaTimestamp(intervals_dates[z],intervals_dates[z+1],GPSrecords,list_infected)\\n events_gps = nearest_neighbor(infected, uninfected, d)\\n events_gps = events_gps.drop(['geometry','closest_stop_geom'], axis=1)\\n print(len(events_gps))\\n if(len(events_gps)!=0):\\n list_gpsevents.append(events_gps.reset_index(drop=True))\\n else:\\n events_gps=pd.DataFrame()\\n list_gpsevents.append(events_gps)\\n #GPSevents=pd.concat(list_gpsevents).reset_index(drop=True)\\n #return GPSevents\\n return list_gpsevents\",\n \"def adjust_filter(self, queryset):\\n new_queryset = queryset.filter(points__gt=0.0).order_by('-points', 'rate')\\n return self.validate_queryset(new_queryset)\",\n \"def prepare_filter_params(context, plan_name=None, **kw):\\n from debra.models import Influencer\\n from debra import logical_categories\\n from django.core.cache import get_cache\\n cache = get_cache('memcached')\\n params = None #cache.get('filter_params')\\n if not params:\\n # influencers = Influencer.objects.filter(\\n # show_on_search=True).exclude(blacklisted=True)\\n # influencers = influencers.filter(\\n # score_popularity_overall__isnull=False)\\n # influencers = influencers.distinct()\\n popularity = [\\n {\\n \\\"title\\\": \\\"Small\\\",\\n },\\n {\\n \\\"title\\\": \\\"Medium\\\",\\n },\\n {\\n \\\"title\\\": \\\"Large\\\",\\n }\\n ]\\n engagement = [\\n {\\n \\\"title\\\": \\\"0-20\\\",\\n },\\n {\\n \\\"title\\\": \\\"21-40\\\",\\n },\\n {\\n \\\"title\\\": \\\"41-60\\\",\\n },\\n {\\n \\\"title\\\": \\\"61-80\\\",\\n },\\n {\\n \\\"title\\\": \\\"81+\\\",\\n },\\n ]\\n\\n price_ranges = [\\n {\\n \\\"title\\\": \\\"Cheap\\\",\\n \\\"text\\\": \\\"Primarily In-expensive\\\"\\n },\\n # {\\n # \\\"title\\\": \\\"Mid-level\\\",\\n # },\\n { \\n \\\"title\\\": \\\"Expensive\\\",\\n \\\"text\\\": \\\"Primarily High-end\\\"\\n }\\n ]\\n\\n genders = [\\n {\\n \\\"title\\\": \\\"Female\\\",\\n },\\n {\\n \\\"title\\\": \\\"Male\\\",\\n },\\n ]\\n\\n social = [\\n {\\n \\\"value\\\": \\\"Facebook\\\",\\n \\\"icon\\\": \\\"icon-social_facebook\\\"\\n },\\n {\\n \\\"value\\\": \\\"Pinterest\\\",\\n \\\"icon\\\": \\\"icon-social_pinterest2\\\"\\n },\\n {\\n \\\"value\\\": \\\"Twitter\\\",\\n \\\"icon\\\": \\\"icon-social_twitter\\\"\\n },\\n {\\n \\\"value\\\": \\\"Instagram\\\",\\n \\\"icon\\\": \\\"icon-social_instagram2\\\"\\n },\\n {\\n \\\"value\\\": \\\"Youtube\\\",\\n \\\"icon\\\": \\\"icon-social_youtube\\\"\\n },\\n ]\\n\\n age_groups = [\\n {\\n \\\"value\\\": \\\"0_19\\\",\\n \\\"icon\\\": \\\"0 - 19\\\"\\n },\\n {\\n \\\"value\\\": \\\"20_24\\\",\\n \\\"icon\\\": \\\"20 - 24\\\"\\n },\\n {\\n \\\"value\\\": \\\"25_29\\\",\\n \\\"icon\\\": \\\"25 - 29\\\"\\n },\\n {\\n \\\"value\\\": \\\"30_34\\\",\\n \\\"icon\\\": \\\"30 - 34\\\"\\n },\\n {\\n \\\"value\\\": \\\"35_39\\\",\\n \\\"icon\\\": \\\"35 - 39\\\"\\n },\\n {\\n \\\"value\\\": \\\"40\\\",\\n \\\"icon\\\": \\\"40+\\\",\\n }\\n ]\\n\\n activity = [{\\\"value\\\": \\\"Blog\\\", \\\"icon\\\": \\\"icon icon-letter_quotes2\\\"}] + social\\n\\n categories = []\\n\\n brands = []\\n\\n locations = redis_cache.get('toplocs') or []\\n # locations = Influencer.get_locations_list(num_results=200)\\n # locations = Influencer.get_locations_list(num_results=None)\\n\\n tags = kw.get('tags', [])\\n\\n source = [{\\\"title\\\": \\\"Signup\\\", \\\"value\\\": \\\"blogger_signup\\\"}]\\n\\n params = {\\n 'show_filters': True,\\n 'popularity': list(popularity),\\n 'engagement': list(engagement),\\n 'categories': list(categories),\\n 'brands': list(brands),\\n 'priceranges': list(price_ranges),\\n 'locations': list(locations),\\n 'genders': list(genders),\\n 'social': list(social),\\n 'activity': list(activity),\\n 'tags': list(tags),\\n 'source': list(source),\\n 'age_groups': list(age_groups),\\n 'enabled_filters': [\\n \\\"popularity\\\", \\\"engagement\\\", \\\"categories\\\", \\\"brands\\\",\\n \\\"priceranges\\\", \\\"location\\\", \\\"genders\\\", \\\"socials\\\", \\\"activity\\\",\\n \\\"tags\\\", \\\"likes\\\", \\\"shares\\\", \\\"comments\\\", \\\"source\\\", \\\"avgAge\\\",\\n \\\"customCategories\\\", \\\"customOccupation\\\", \\\"customSex\\\", \\\"customEthnicity\\\",\\n \\\"customTags\\\", \\\"customLanguage\\\", \\\"customAgeRange\\\",]\\n }\\n cache.set('filter_params', params)\\n\\n for loc in params.get('locations', []):\\n loc['value'] = loc['title']\\n\\n if True: #settings.DEBUG:\\n params['categories'] = [{\\\"title\\\": \\\"Fashion\\\", \\\"category\\\": \\\"fashion\\\"},\\n {\\\"title\\\": \\\"Food\\\", \\\"category\\\": \\\"food\\\"},\\n {\\\"title\\\": \\\"Kids\\\", \\\"category\\\": \\\"kids\\\"},\\n {\\\"title\\\": \\\"Beauty\\\", \\\"category\\\": \\\"beauty\\\"},\\n {\\\"title\\\": \\\"Travel\\\", \\\"category\\\": \\\"travel\\\"}]\\n else:\\n params['categories'] = []\\n \\n return params\",\n \"def get_timeline_filters(self, req):\",\n \"def queryGenerator(itemset,venue,min_runs):\\n level=len(itemset)\\n partners=[[] for k in range(level)]\\n for j in range(level):\\n for i in range(level):\\n partners[i].append({'partner'+str(j+1):itemset[i]})\\n k=itemset.pop(0)\\n itemset.append(k)\\n ors=[]\\n for cond in partners:\\n ors.append({'$and':cond})\\n \\n match={}\\n match['$or']=ors\\n match['total_runs']={'$gte':30}\\n if venue:\\n match['venue']=venue\\n\\n return match\",\n \"def filter_metrics_choices(self): \\n cols = pd.Series(tdr.get_catalog().tubidw.all_metric_hourly.columns)\\n filter_metrics = ['no filters'] + cols[cols.str.endswith(tuple(['_count', '_sec']))].tolist()\\n return filter_metrics\",\n \"def create_in_range_lst(source_features: list, user_zip_code: str, radius: int,\\n active_set: set, second_dose: bool,\\n provider_filter: list) -> list:\\n in_range_locs = []\\n user_coords = ZIP_MAP_DICT[user_zip_code][0]\\n for loc in source_features:\\n if loc['properties']['appointments_available'] and\\\\\\n loc['properties']['provider_brand'].lower() in active_set and\\\\\\n (loc['properties']['appointments_available_all_doses'] is True or\\n loc['properties']['appointments_available_2nd_dose_only'] is\\n second_dose) and \\\\\\n (len(provider_filter) == 0 or\\n loc['properties']['provider_brand_name'] in provider_filter):\\n # format [latitude, longitude]\\n loc_coord = loc['geometry']['coordinates'][::-1]\\n if loc_coord != [None, None]:\\n if earth_distance(loc_coord[0], loc_coord[1],\\n user_coords[0], user_coords[1]) <= radius:\\n in_range_locs.append(loc)\\n return in_range_locs\",\n \"def filter(self, filters):\",\n \"def filter_data(self,tod,sel,medfilt_size):\\n \\n filters = np.zeros((tod.shape[0],tod.shape[1],tod.shape[2],int(np.sum(sel))))\\n for ifeed in tqdm(self.feedlist,desc=f'{self.name}:filters:{self.source}'):\\n feed_tod = tod[ifeed,...] \\n for isb in range(tod.shape[1]):\\n for ichan in range(tod.shape[2]):\\n z = feed_tod[isb,ichan,sel]\\n bad = np.where(np.isnan(z))[0]\\n if len(bad) == len(z):\\n continue\\n if len(bad) > 0:\\n good = np.where(np.isfinite(z))[0]\\n \\n nearest = [good[np.argmin(np.abs(good-b))] for b in bad]\\n z[bad] = z[nearest]\\n filters[ifeed,isb,ichan,:] = median_filter(z,medfilt_size)\\n \\n return filters\",\n \"def filter_viable_offers(want, have, offers) -> List:\\n return [x for x in offers if is_offer_viable(want, have, x) is True]\",\n \"def filter_potential_deal_table(apply_n_clicks, potential_deal_table_data,\\n selected_year, selected_make, selected_model, min_odometer,\\n max_odometer, min_price, max_price, min_offer_price,\\n max_offer_price):\\n potential_deal_db_data = DBApi.get_instance().potential_records\\n filtered_year_ids = []\\n filtered_make_ids = []\\n filtered_model_ids = []\\n filtered_min_odometer_ids = []\\n filtered_max_odometer_ids = []\\n filtered_min_price_ids = []\\n filtered_max_price_ids = []\\n filtered_min_offer_price_ids = []\\n filtered_max_offer_price_ids = []\\n\\n if selected_year or selected_make or min_odometer or max_odometer or min_price or \\\\\\n max_price or min_offer_price or max_offer_price:\\n # Odometer filter\\n if min_odometer and max_odometer:\\n if int(max_odometer) < int(min_odometer):\\n return [\\n potential_deal_table_data,\\n \\\"Max odometer value should be greater than min odometer value\\\",\\n True,\\n 5000\\n ]\\n if min_price and max_price:\\n if int(max_price) < int(min_price):\\n return [\\n potential_deal_table_data,\\n \\\"Max price value should be greater than min price value\\\",\\n True,\\n 5000\\n ]\\n\\n if min_offer_price and max_offer_price:\\n if int(max_offer_price) < int(min_offer_price):\\n return [\\n potential_deal_table_data,\\n \\\"Max offer price MMR value should be greater \\\"\\n \\\"than min offer price MMR value\\\",\\n True,\\n 5000\\n ]\\n\\n for data in potential_deal_db_data:\\n # Year filter\\n if selected_year:\\n for year in selected_year:\\n if year in data[\\\"make_model_year\\\"]:\\n filtered_year_ids.append(data[\\\"PotentialDealID\\\"])\\n break\\n else:\\n filtered_year_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n # Make filter\\n if selected_make:\\n for make in selected_make:\\n if make in data[\\\"make_model_year\\\"].lower():\\n filtered_make_ids.append(data[\\\"PotentialDealID\\\"])\\n else:\\n filtered_make_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n # Model filter\\n if selected_model:\\n for model in selected_model:\\n if model in data[\\\"make_model_year\\\"].lower():\\n filtered_model_ids.append(data[\\\"PotentialDealID\\\"])\\n else:\\n filtered_model_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n # Min odometer filter\\n if min_odometer:\\n if int(data[\\\"odometer\\\"]) >= int(min_odometer):\\n filtered_min_odometer_ids.append(data[\\\"PotentialDealID\\\"])\\n else:\\n filtered_min_odometer_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n # Max odometer filter\\n if max_odometer:\\n if int(data[\\\"odometer\\\"]) <= int(max_odometer):\\n filtered_max_odometer_ids.append(data[\\\"PotentialDealID\\\"])\\n else:\\n filtered_max_odometer_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n # Min price filter\\n if min_price:\\n if int(data[\\\"price\\\"]) >= int(min_price):\\n filtered_min_price_ids.append(data[\\\"PotentialDealID\\\"])\\n else:\\n filtered_min_price_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n # Max price filter\\n if max_price:\\n if int(data[\\\"price\\\"]) <= int(max_price):\\n filtered_max_price_ids.append(data[\\\"PotentialDealID\\\"])\\n else:\\n filtered_max_price_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n # Min offer price filter\\n if min_offer_price:\\n if int(data[\\\"OfferPricePctMMR\\\"]) >= int(min_offer_price):\\n filtered_min_offer_price_ids.append(data[\\\"PotentialDealID\\\"])\\n else:\\n filtered_min_offer_price_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n # Max offer price filter\\n if max_offer_price:\\n if int(data[\\\"OfferPricePctMMR\\\"]) <= int(max_offer_price):\\n filtered_max_offer_price_ids.append(data[\\\"PotentialDealID\\\"])\\n else:\\n filtered_max_offer_price_ids.append(data[\\\"PotentialDealID\\\"])\\n\\n filtered_ids = set(filtered_year_ids).intersection(\\n set(filtered_make_ids),\\n set(filtered_model_ids),\\n set(filtered_min_odometer_ids),\\n set(filtered_max_odometer_ids),\\n set(filtered_min_price_ids),\\n set(filtered_max_price_ids),\\n set(filtered_min_offer_price_ids),\\n set(filtered_max_offer_price_ids)\\n )\\n filtered_data = [\\n data\\n for data in potential_deal_db_data\\n if data[\\\"PotentialDealID\\\"] in filtered_ids\\n ]\\n return [filtered_data, \\\"\\\", False, 2000]\\n return [potential_deal_db_data, \\\"\\\", False, 2000]\",\n \"def extract_tt_by_periods(ttri, periods, start_time, end_time, filters):\\n logger = getLogger(__name__)\\n # sess = conn.get_session()\\n das = {}\\n all_wz_features = {}\\n all_wz_laneconfigs = {}\\n\\n # collecting daily data\\n for prd in periods:\\n logger.debug('>>>> retrieving data for %s' % prd.get_date_string())\\n year = prd.start_date.year\\n sdate = prd.start_date\\n edate = prd.end_date\\n if year not in das:\\n da_tt = tt.TravelTimeDataAccess(year)\\n da_tt_wz = tt_workzone.TTWorkZoneDataAccess(year)\\n da_tt_wz_feature = wz_feature.WZFeatureDataAccess()\\n da_tt_wz_lncfg = wz_laneconfig.WZLaneConfigDataAccess()\\n da_tt_weather = tt_weather.TTWeatherDataAccess(year)\\n da_tt_snowmgmt = tt_snowmgmt.TTSnowManagementDataAccess(year)\\n da_tt_incident = tt_incident.TTIncidentDataAccess(year)\\n da_tt_specialevent = tt_specialevent.TTSpecialeventDataAccess(year)\\n das[year] = (\\n da_tt, da_tt_wz, da_tt_wz_feature, da_tt_wz_lncfg, da_tt_weather, da_tt_snowmgmt, da_tt_incident,\\n da_tt_specialevent)\\n\\n (da_tt, da_tt_wz, da_tt_wz_feature, da_tt_wz_lncfg, da_tt_weather, da_tt_snowmgmt, da_tt_incident,\\n da_tt_specialevent) = das[year]\\n\\n # traveltimes = da_tt.list_by_period(ttri.id, self.prd)\\n weathers = da_tt_weather.list(ttri.id, sdate, edate, as_model=True)\\n \\\"\\\"\\\":type: list[pyticas_tetres.ttrms_types.WeatherInfo] \\\"\\\"\\\"\\n workzones = da_tt_wz.list(ttri.id, sdate, edate, as_model=True)\\n \\\"\\\"\\\":type: list[pyticas_tetres.ttrms_types.WorkZoneInfo] \\\"\\\"\\\"\\n incidents = da_tt_incident.list(ttri.id, sdate, edate, as_model=True)\\n \\\"\\\"\\\":type: list[pyticas_tetres.ttrms_types.IncidentInfo] \\\"\\\"\\\"\\n snowmgmts = da_tt_snowmgmt.list(ttri.id, sdate, edate, as_model=True)\\n \\\"\\\"\\\":type: list[pyticas_tetres.ttrms_types.SnowManagementInfo] \\\"\\\"\\\"\\n specialevents = da_tt_specialevent.list(ttri.id, sdate, edate, as_model=True)\\n \\\"\\\"\\\":type: list[pyticas_tetres.ttrms_types.SpecialEventInfo] \\\"\\\"\\\"\\n traveltimes = da_tt.list_by_period(ttri.id, prd)\\n \\\"\\\"\\\":type: list[pyticas_tetres.ttrms_types.TravelTimeInfo] \\\"\\\"\\\"\\n\\n if not any(weathers):\\n logger.debug('>>>> end of retrieving data for %s (no weather data)' % prd.get_date_string())\\n continue\\n\\n extras = {\\n 'weathers': {_tt.id: [] for _tt in traveltimes},\\n 'workzones': {_tt.id: [] for _tt in traveltimes},\\n 'incidents': {_tt.id: [] for _tt in traveltimes},\\n 'specialevents': {_tt.id: [] for _tt in traveltimes},\\n 'snowmgmts': {_tt.id: [] for _tt in traveltimes},\\n }\\n \\\"\\\"\\\":type: dict[str, dict[int, list]]\\\"\\\"\\\"\\n\\n _put_to_bucket(ttri, weathers, extras['weathers'], da_tt_weather, year, all_wz_features, all_wz_laneconfigs, das)\\n _put_to_bucket(ttri, workzones, extras['workzones'], da_tt_wz, year, all_wz_features, all_wz_laneconfigs, das)\\n _put_to_bucket(ttri, incidents, extras['incidents'], da_tt_incident, year, all_wz_features, all_wz_laneconfigs, das)\\n _put_to_bucket(ttri, snowmgmts, extras['snowmgmts'], da_tt_snowmgmt, year, all_wz_features, all_wz_laneconfigs, das)\\n _put_to_bucket(ttri, specialevents, extras['specialevents'], da_tt_specialevent, year, all_wz_features, all_wz_laneconfigs, das)\\n\\n for tti in traveltimes:\\n _tt_weathers = extras['weathers'][tti.id]\\n extdata = ExtData(tti,\\n _tt_weathers[0] if _tt_weathers else None,\\n extras['incidents'][tti.id],\\n extras['workzones'][tti.id],\\n extras['specialevents'][tti.id],\\n extras['snowmgmts'][tti.id])\\n\\n if start_time <= tti.str2datetime(tti.time).time() <= end_time:\\n for ef in filters:\\n try:\\n ef.check(extdata)\\n except Exception as ex:\\n tb.traceback(ex)\\n logger.debug('>>>> end of retrieving data for %s (error occured 1)' % prd.get_date_string())\\n continue\\n else:\\n for ef in filters:\\n try:\\n ef.check_outofrange(extdata)\\n except Exception as ex:\\n tb.traceback(ex)\\n logger.debug('>>>> end of retrieving data for %s (error occured 2)' % prd.get_date_string())\\n continue\\n\\n del extras\\n logger.debug('>>>> end of retrieving data for %s' % prd.get_date_string())\\n\\n # sess.close()\",\n \"def _apply_filters(self, df):\\n df = df[(df['Date'] >= self.start_date) &\\n (df['Date'] <= self.end_date)]\\n return df\",\n \"def Filter(self, info):\\n\\n add_item = True\\n \\n if add_item and (self.use_only_ids != None) and (uid not in self.use_only_ids):\\n add_item = False\\n \\n if add_item and (info['latlong'] == None):\\n add_item = False\\n \\n if add_item and (self.size != None) and (info['size'] < self.size):\\n add_item = False\\n \\n if add_item and (self.expert_rank != None) and (info['expert_rank'] < self.expert_rank):\\n add_item = False\\n \\n if add_item and (self.kosher != None) and (self.kosher == True and info['kosher'] == False):\\n add_item = False\\n \\n if add_item and (self.visiting_center != None) and (self.visiting_center == True and info['visiting_center'] == False):\\n add_item = False\\n \\n if add_item and (self.visiting_center_free_admission != None) and (self.visiting_center_free_admission == True and info['visiting_center_free_admission'] == False):\\n add_item = False\\n \\n if add_item and self.visit_time != None:\\n day_of_visit = time.strftime(\\\"%A\\\", time.localtime(self.visit_time)).lower()\\n if info['hours'][day_of_visit] != None:\\n closing_at_that_day = time.mktime(time.strptime(time.strftime(\\\"%A, %d %b %Y\\\", time.localtime(self.visit_time)) + \\\" %d:00:00\\\" % (info['hours'][day_of_visit]), \\\"%A, %d %b %Y %H:%M:%S\\\"))\\n if self.visit_time > (closing_at_that_day - self._delta_time_before_close):\\n add_item = False\\n if day_of_visit == 'saturday' and self.kosher == True:\\n add_item = False\\n \\n if add_item and self.use_weather: \\n if not self.weather_client.GoodForWinery(self.weather_client.GetCondition(info['latlong'])):\\n add_item = False\\n \\n return add_item\",\n \"def get_entities_since_ts(self, query_field_name, timestamp, optional_filters, refresh_authentication=False):\\n query = { }\\n\\n if query_field_name:\\n query[query_field_name] = readable_datetime(timestamp) # utc datetime format\\n\\n # add any additional query parameters\\n groups_filter = []\\n impact_filter = None\\n if optional_filters:\\n # groups and relevance are managed after the api call is made\\n if \\\"groups\\\" in optional_filters:\\n groups_filter = optional_filters.pop('groups')\\n if \\\"impact\\\" in optional_filters:\\n impact_filter = int(optional_filters.pop('impact'))\\n\\n for k,v in optional_filters.items():\\n query[k] = v\\n\\n LOG.debug(query)\\n response, err_msg = self.api_call(\\\"GET\\\", 'alerts', query, refresh_authentication=refresh_authentication)\\n\\n results = response if isinstance(response, dict) else response.json()\\n\\n # trim results by optional filters\\n if not err_msg and (groups_filter or impact_filter):\\n filtered_results = []\\n for alert in results['result']:\\n accept_filtered = False\\n # both groups_filter and impact_filter need to succeed if both are specified\\n if groups_filter:\\n # get the endpoint groups and test if list and filters intersect\\n endpoint_groups = [group['name'] for group in alert.get(\\\"endpoint\\\", {}).get(\\\"groups\\\", [])]\\n if list(set(groups_filter) & set(endpoint_groups)):\\n accept_filtered = True\\n\\n if impact_filter:\\n accept_filtered = bool(alert.get(\\\"impact\\\") >= impact_filter)\\n\\n if accept_filtered:\\n filtered_results.append(alert)\\n\\n LOG.info(\\\"Original List: %s. Filtered List: %s\\\", len(results), len(filtered_results))\\n results = { \\\"result\\\": filtered_results }\\n\\n return results, err_msg\",\n \"def filtercmd(client, args):\\n try:\\n phrases = [list(group) for k, group in groupby(args, lambda x: x == \\\"OR\\\") if not k]\\n for phrase in phrases:\\n # we do before/after by id not by timestamp\\n if phrase[0] in ('before', 'b4', 'after', 'af') and len(phrase) > 1:\\n r = client.req_by_id(phrase[1], headers_only=True)\\n phrase[1] = str(time_to_nsecs(r.time_start))\\n client.context.apply_phrase(phrases)\\n except InvalidQuery as e:\\n print(e)\",\n \"def get_active_filter():\\n return (Q(start_date__gte=timezone.now()) |\\n Q(end_date__gte=timezone.now()))\",\n \"def queryset(self, request, queryset):\\n if self.value() == 'p':\\n return queryset.filter(pointe=True)\\n if self.value() == 'rapp':\\n return queryset.filter(rapp__isnull=False)\\n if self.value() == 'rien':\\n return queryset.filter(rapp__isnull=True, pointe=False)\\n if self.value() == 'pr':\\n # comme il y a trois position, si l'on exclue les ni rapproche ni pointe on a les rapproche ou pointe\\n return queryset.exclude(rapp__isnull=True, pointe=False)\\n if self.value() == 'nrapp':\\n return queryset.filter(rapp__isnull=True)\",\n \"def queryset(self, request, queryset):\\n if self.value() == 'examine':\\n return queryset.filter(ignored_at=None, address_1__isnull=False, longitude_position=None).exclude(address_1='')\\n if self.value() == 'done':\\n return queryset.filter(longitude_position__isnull=False)\\n if self.value() == 'ignore':\\n return queryset.filter(ignored_at__isnull=False)\",\n \"def filter_tod(data,feedtod,ifeed,level2='level2'):\\n nBands, nChans,nSamples = feedtod.shape\\n\\n mask = np.zeros(nSamples,dtype=bool)\\n\\n medfilt_coefficient = data[f'{level2}/Statistics/filter_coefficients'][ifeed,...]\\n atmos = data[f'{level2}/Statistics/atmos'][ifeed,...]\\n atmos_coefficient = data[f'{level2}/Statistics/atmos_coefficients'][ifeed,...]\\n scan_edges = data[f'{level2}/Statistics/scan_edges'][...]\\n\\n az = data['level1/spectrometer/pixel_pointing/pixel_az'][ifeed,:]\\n el = data['level1/spectrometer/pixel_pointing/pixel_el'][ifeed,:]\\n for iscan,(start,end) in enumerate(scan_edges):\\n median_filter = data[f'{level2}/Statistics/FilterTod_Scan{iscan:02d}'][ifeed,...]\\n mask[start:end] = True\\n N = int((end-start))\\n for iband in range(nBands):\\n for ichan in range(nChans):\\n\\n mdl = Statistics.AtmosGroundModel(atmos[iband,iscan],az[start:end],el[start:end]) *\\\\\\n atmos_coefficient[iband,ichan,iscan,0]\\n mdl += median_filter[iband,:N] * medfilt_coefficient[iband,ichan,iscan,0]\\n feedtod[iband,ichan,start:end] -= mdl\\n feedtod[iband,ichan,start:end] -= np.nanmedian(feedtod[iband,ichan,start:end])\\n\\n return feedtod, mask\",\n \"def get_timeline_events(self, req, start, stop, filters):\",\n \"def get_filters():\\n \\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n \\n \\\"\\\"\\\"Messeges to genrate filters\\\"\\\"\\\"\\n\\tnote_messege = 'In this project, we make use of Python to explore data related to bike share systems for three major cities in the United States\\\\n'\\n welcome_messege = 'Hello! Let\\\\'s explore some US bikeshare data!\\\\n'\\n enter_city_name_messege = 'Which city would you like to filter by? Chicago, New York City or Washington? '\\n filter_definition_messege = '\\\\nWould you like to filter the data by - \\\\n1. Month\\\\n2. Day\\\\n3. Both\\\\n4. No Filter\\\\n\\\\nPlease choose the appropriate filter name.\\\\nNote: Incorrect filter name will result as \\\\'no filter selected\\\\' by the user.\\\\n'\\n enter_filter_messege = 'Desired filter (e.g: Month, Day, Both or No Filter): '\\n enter_month_name_messege = 'Enter month name (e.g: january, february, march, april, may or june): '\\n enter_day_name_messege = 'Enter day of the week (e.g: monday, tuesday, wednesday, thursday, friday, saturday, sunday): '\\n exception_messege = '\\\\nWarning! That is not a valid input.\\\\n'\\n warning_city_name_messege = '\\\\nWarning! Invalid city name. Select city name from the following cities only - Chicago, New York City or Washington.' \\n warning_month_name_messege = '\\\\nWarning! Invalid month name. Select month name from the following months only - january, february, march, april, may or june'\\n warning_day_name_messege = '\\\\nWarning! Invalid day name. Select day name from the following days only - monday, tuesday, wednesday, thursday, friday, saturday, sunday'\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n \\n \\\"\\\"\\\"City, Month and Day List\\\"\\\"\\\"\\n city_list = ['chicago', 'new york city', 'washington']\\n month_list = ['january', 'february', 'march', 'april', 'may', 'june']\\n day_list = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n \\n\\tprint(note_messege)\\n print(welcome_messege)\\n \\n # TO DO: get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs \\n while True:\\n try:\\n city = input(enter_city_name_messege)\\n break\\n except:\\n print(exception_messege)\\n \\n while city.lower() not in city_list:\\n while True:\\n try: \\n print(warning_city_name_messege)\\n city = input(enter_city_name_messege)\\n break\\n except:\\n print(exception_messege)\\n \\n print(filter_definition_messege)\\n while True:\\n try:\\n filter_choice = input(enter_filter_messege)\\n break\\n except:\\n print(exception_messege)\\n while True: \\n if filter_choice.lower() == 'month':\\n # TO DO: get user input for month (all, january, february, ... , june)\\n while True:\\n try:\\n month = input(enter_month_name_messege) \\n break\\n except:\\n print(exception_messege)\\n while month.lower() not in month_list:\\n while True:\\n try: \\n print(warning_month_name_messege)\\n month = input(enter_month_name_messege) \\n break\\n except:\\n print(exception_messege)\\n day = 'all'\\n break\\n \\n elif filter_choice.lower() == 'day':\\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday) \\n while True:\\n try:\\n day = input(enter_day_name_messege)\\n break\\n except:\\n print(exception_messege)\\n while day.lower() not in day_list:\\n while True:\\n try: \\n print(warning_day_name_messege)\\n day = input(enter_day_name_messege) \\n break\\n except:\\n print(exception_messege)\\n month = 'all'\\n break\\n \\n elif filter_choice.lower() == 'both':\\n # TO DO: get user input for month (all, january, february, ... , june)\\n while True:\\n try:\\n month = input(enter_month_name_messege)\\n break\\n except:\\n print(exception_messege)\\n while month.lower() not in month_list:\\n while True:\\n try: \\n print(warning_month_name_messege)\\n month = input(enter_month_name_messege) \\n break\\n except:\\n print(exception_messege)\\n # TO DO: get user input for day of week (all, monday, tuesday, ... sunday)\\n while True:\\n try:\\n day = input(enter_day_name_messege)\\n break\\n except:\\n print(exception_messege)\\n while day.lower() not in day_list:\\n while True:\\n try: \\n print(warning_day_name_messege)\\n day = input(enter_day_name_messege) \\n break\\n except:\\n print(exception_messege)\\n break\\n \\n else:\\n month = 'all'\\n day = 'all'\\n break\\n \\n\\n print('-'*40)\\n return city.lower(), month.lower(), day.lower()\",\n \"def test_nearest_filter(self):\\n for airport, reports, count in (\\n (True, True, 6),\\n (True, False, 16),\\n (False, True, 6),\\n (False, False, 30),\\n ):\\n stations = station.nearest(30, -80, 30, airport, reports, 1.5)\\n self.assertEqual(len(stations), count)\",\n \"def track_request(params):\\n\\n if len(params) == 0:\\n number_of_orders = \\\"10\\\"\\n field = None\\n from_date = None\\n condition_1 = None\\n to_date = None\\n condition_2 = None\\n status = None\\n value = None\\n condition_3 = None\\n else:\\n number_of_orders = params['number_of_orders'] if len(params['number_of_orders']) != 0 else \\\"20\\\"\\n field = \\\"created_at\\\"\\n from_date = params['from_date'] + \\\" 00:00:00\\\" if len(params['from_date']) != 0 else \\\"2000-01-01 00:00:00\\\" \\n condition_1 = \\\"gteq\\\"\\n to_date = params['to_date'] + \\\" 23:59:59\\\" if len(params['to_date']) != 0 else \\\"2100-12-31 23:59:59\\\"\\n condition_2 = \\\"lteq\\\"\\n status = None if params['status'] == \\\"None\\\" else \\\"status\\\"\\n value = None if params['status'] == \\\"None\\\" else params['status']\\n condition_3 = None if params['status'] == \\\"None\\\" else \\\"eq\\\"\\n\\n generate_request = oAuth_magento()\\n\\n payload = { \\\"searchCriteria[filter_groups][0][filters][0][field]\\\": field,\\n \\\"searchCriteria[filter_groups][0][filters][0][value]\\\": from_date,\\n \\\"searchCriteria[filter_groups][0][filters][0][condition_type]\\\": condition_1,\\n\\n \\\"searchCriteria[filter_groups][1][filters][0][field]\\\": field,\\n \\\"searchCriteria[filter_groups][1][filters][0][value]\\\": to_date,\\n \\\"searchCriteria[filter_groups][1][filters][0][condition_type]\\\": condition_2,\\n\\n \\\"searchCriteria[filter_groups][2][filters][0][field]\\\": status,\\n \\\"searchCriteria[filter_groups][2][filters][0][value]\\\": value,\\n \\\"searchCriteria[filter_groups][2][filters][0][condition_type]\\\": condition_3,\\n \\n \\\"searchCriteria[pageSize]\\\": number_of_orders,\\n \\\"searchCriteria[sortOrders][0][field]\\\":\\\"created_at\\\",\\n \\\"fields\\\": \\\"items[increment_id,base_currency_code,grand_total,created_at,status,billing_address[company,firstname,lastname]]\\\",\\n }\\n\\n response = requests.request(\\\"GET\\\", url=generate_request[0], headers=generate_request[1], params=payload)\\n # with open('temp_files/magento_orders_test.json','w') as f:\\n # f.write(response.text)\\n json_response = json.loads(response.text)\\n for ele in json_response['items']:\\n for key, val in ele.items():\\n if key == 'billing_address':\\n name_container = ele.pop(key)\\n try:\\n ele['purchasing_institute'] = name_container['company']\\n except:\\n ele['purchasing_institute'] = name_container['firstname'] + ' ' + name_container['lastname']\\n else:\\n pass\\n col_headers = list((json_response['items'][0]).keys())\\n return json_response['items'], col_headers\",\n \"def get_rides(cls, **kwargs):\\n\\n\\n q = cls.query.options(db.joinedload('user'))\\n\\n if kwargs.get('start_lat'):\\n deg = float(kwargs.get('deg'))\\n start_lat = float(kwargs.get('start_lat'))\\n start_lng = float(kwargs.get('start_lng'))\\n\\n q = q.filter(\\n ( (cls.start_lat < str(start_lat + deg)) &\\n (cls.start_lat > str(start_lat - deg))\\n ) &\\n ( (cls.start_lng < str(start_lng + deg)) &\\n (cls.start_lng > str(start_lng - deg))\\n ))\\n\\n if kwargs.get('end_lat'):\\n deg = float(kwargs.get('deg'))\\n end_lat = float(kwargs.get('end_lat'))\\n end_lng = float(kwargs.get('end_lng'))\\n q = q.filter(\\n ( (cls.end_lat < str(end_lat + deg)) &\\n (cls.end_lat > str(end_lat - deg))\\n ) &\\n ( (cls.end_lng < str(end_lng + deg)) &\\n (cls.end_lng > str(end_lng - deg))\\n ))\\n\\n\\n if kwargs.get('date_from'):\\n date_from = kwargs.get('date_from')\\n\\n q = q.filter((cast(cls.start_timestamp, Date) >= date_from))\\n\\n if kwargs.get('date_to'):\\n date_to = kwargs.get('date_to')\\n \\n q = q.filter((cast(cls.start_timestamp, Date) <= date_to))\\n\\n # print '\\\\n\\\\nhiii: {}\\\\n\\\\n'.format(kwargs.get('start_time'))\\n \\n # q = q.filter(cast(cls.start_timestamp, Time) >= start_time)\\n # if kwargs.get('start_time') >= '00:00:00' kwargs.get('start_time') and < \\\"00:08:00\\\":\\n # pass\\n\\n # print '\\\\n\\\\n\\\\n*STARTTIME*\\\\n{}, {}\\\\n\\\\n\\\\n'.format(start_time, type(start_time))\\n\\n # q = q.filter(cast(cls.start_timestamp, Time) >= start_time)\\n\\n if kwargs.get('cost'):\\n cost = int(kwargs.get('cost'))\\n q = q.filter(cls.cost < cost)\\n\\n start_time = kwargs.get('start_time')\\n if start_time >= time(0,0) and start_time < time(8,0):\\n q1 = q.filter(cast(cls.start_timestamp, Time) >= start_time)\\n q2 = q.filter(cast(cls.start_timestamp, Time) < time(8, 0))\\n q = q1.intersect(q2)\\n else:\\n q1 = q.filter(cast(cls.start_timestamp, Time) >= start_time)\\n q2 = q.filter(cast(cls.start_timestamp, Time) < time(8, 0))\\n q = q1.union(q2)\\n\\n if kwargs.get('order_by') == 'date':\\n q = q.order_by(cls.start_timestamp)\\n\\n if kwargs.get('order_by') == 'time':\\n sort_order = case(value=(cast(cls.start_timestamp, Time)), whens=order_by_time)\\n q = q.order_by(sort_order)\\n\\n if kwargs.get('order_by') == 'cost':\\n q = q.order_by(cls.cost)\\n\\n if kwargs.get('limit'):\\n limit_number = int(kwargs.get('limit'))\\n q = q.limit(limit_number)\\n\\n if kwargs.get('offset'):\\n offset_number = int(kwargs.get('offset'))\\n q = q.offset(offset_number)\\n\\n if kwargs.get('count'):\\n rides = q.count()\\n else:\\n rides = q.all()\\n print '\\\\n\\\\n{}\\\\n\\\\n'.format(rides)\\n\\n return rides\",\n \"def get_queryset(self):\\n\\n fl = self.request.QUERY_PARAMS.get('fl', None)\\n win = self.request.QUERY_PARAMS.get('win', None)\\n win_filter = Q(orderstatus__in=['Shipped', 'Unshipped', 'Processing'], fulfillmentchannel='MFN')\\n #win_filter = Q(orderstatus__in=['Unshipped', 'Processing'], fulfillmentchannel='MFN')\\n\\n queryset = None\\n if fl is not None and fl.isdigit():\\n logger.info(\\\"Got filter id: %s\\\", fl)\\n try:\\n filter = Filter.objects.get(pk=int(fl))\\n if filter:\\n ancestor_logic = Q() #Create Q object to hold other query\\n #If filter is only root node\\n if filter.is_root_node():\\n ancestor_logic = pickle.loads(filter.logic) #Deserilize the filter logic\\n logger.info(\\\"Filter has only root node, Logic: %s\\\", ancestor_logic)\\n\\n #If filter has parents\\n else:\\n for filter_data in filter.get_ancestors(False, True): #Get all parents including self\\n filter_logic = pickle.loads(filter_data.logic) #Deserilize the filter logic\\n if ancestor_logic.__len__()==0:\\n ancestor_logic = filter_logic\\n else:\\n ancestor_logic = ancestor_logic & filter_logic\\n logger.info(\\\"Filter has parents, Logic: %s\\\", ancestor_logic)\\n\\n if ancestor_logic:\\n queryset = AmazonOrders.objects.filter(ancestor_logic & win_filter) #pass the query object to filter\\n logger.info(\\\"Filter query, Query: %s\\\", queryset.query)\\n\\n except Exception as e:\\n logger.error(\\\"In queryset exception : %s\\\",e)\\n elif win is not None:\\n logic = None\\n if win == 'AFN':\\n logic = Q(fulfillmentchannel=win, orderstatus='Shipped')\\n elif win in ['Pending', 'Canceled']:\\n logic = Q(orderstatus=win)\\n elif win == 'Unshipped':\\n logic = Q(orderstatus=win)\\n\\n if logic:\\n queryset = AmazonOrders.objects.filter(logic)\\n logger.info(\\\"Win query, Query: %s\\\", queryset.query)\\n\\n else:\\n #queryset = AmazonOrders.objects.all()\\n queryset = AmazonOrders.objects.filter(win_filter)\\n logger.info(\\\"Filter not passed, Processing full Query: %s\\\", queryset.query)\\n\\n return queryset\",\n \"def offers_list(update, context):\\n chat = Chat.get(update.message.chat_id)\\n\\n if not chat.cart.subscriptions:\\n text = 'ℹ️ Du får ingen tilbud, hvis du ikke har nogen søgninger.'\\n update.message.reply_text(text)\\n\\n for sub in chat.cart:\\n if not sub.offers:\\n text = f'ℹ️ Søgningen efter \\\"{sub.query}\\\" har ingen tilbud.'\\n update.message.reply_text(text)\\n continue\\n\\n lines = [\\n f'ℹ️ Søgningen efter \\\"{sub.query}\\\" har {len(sub.offers)} tilbud:',\\n ''\\n ]\\n for offer in sub.offers:\\n print(offer, offer.timeleft(), offer.run_till)\\n lines.append(offer_text(offer))\\n\\n update.message.reply_text('\\\\n'.join(lines))\",\n \"def collect_events(helper, ew):\\n\\n opt_start_time_start = helper.get_arg('start_time_start')\\n opt_endpoints = helper.get_arg('endpoints')\\n opt_interval = int(helper.get_arg('interval'))\\n opt_live = False\\n\\n proxy = helper.get_proxy()\\n if proxy:\\n proxy_auth = \\\"{}:{}\\\".format(\\n proxy['proxy_username'], proxy['proxy_password'])\\n proxies = {\\n \\\"https\\\": \\\"{protocol}://{auth}@{host}:{port}/\\\".format(protocol=proxy['proxy_type'], auth=proxy, host=proxy['proxy_url'], port=proxy['proxy_port']),\\n \\\"http\\\": \\\"{protocol}://{auth}@{host}:{port}/\\\".format(protocol=proxy['proxy_type'], auth=proxy, host=proxy['proxy_url'], port=proxy['proxy_port'])\\n }\\n else:\\n proxies = None\\n\\n helper.log_debug(\\n \\\"[-] webex password_type: {}\\\".format(helper.get_global_setting(\\\"password_type\\\")))\\n\\n params = {\\\"opt_username\\\": helper.get_global_setting(\\\"username\\\"),\\n \\\"opt_password\\\": helper.get_global_setting(\\\"password\\\"),\\n \\\"opt_site_name\\\": helper.get_global_setting(\\\"site_name\\\"),\\n \\\"limit\\\": 500,\\n \\\"timezone\\\": \\\"20\\\",\\n # \\\"password_type\\\": authentication_type[\\\"Password Authentication\\\"],\\n # \\\"password_type\\\": authentication_type[\\\"OAuth\\\"],\\n \\\"password_type\\\": authentication_type[helper.get_global_setting(\\\"password_type\\\")],\\n \\\"client_id\\\": helper.get_global_setting(\\\"client_id\\\"),\\n \\\"client_secret\\\": helper.get_global_setting(\\\"client_secret\\\"),\\n \\\"refresh_token\\\": helper.get_global_setting(\\\"refresh_token\\\"),\\n \\\"proxies\\\": proxies}\\n\\n # Historical Data\\n helper.log_debug(\\\"Historical Data\\\")\\n for opt_endpoint in opt_endpoints:\\n helper.log_debug(\\\"[-] \\\\t At {}\\\".format(opt_endpoint))\\n\\n # endtime is midnight of GMT - 3days\\n enddt = datetime.utcnow().date() - timedelta(3)\\n end_time = datetime.combine(\\n enddt, datetime.max.time()).strftime('%m/%d/%Y %H:%M:%S')\\n\\n # create checkpoint key for offest and timestamp\\n timestamp_key = \\\"timestamp_{}_{}_processing\\\".format(\\n helper.get_input_stanza_names(), opt_endpoint)\\n\\n start_time = helper.get_check_point(timestamp_key)\\n if start_time is None:\\n # if it's the 1st time, get the start_time from UI, and then save it in checkpoint\\n start_time = opt_start_time_start\\n helper.save_check_point(timestamp_key, start_time)\\n else:\\n # shift the start_time by 1 second\\n start_time = (datetime.strptime(start_time, '%m/%d/%Y %H:%M:%S') +\\n timedelta(seconds=1)).strftime('%m/%d/%Y %H:%M:%S')\\n\\n helper.log_debug(\\\"Start time: {}\\\".format(start_time))\\n helper.log_debug(\\\"End time: {}\\\".format(end_time))\\n\\n # Update Parameters\\n params.update({\\\"mode\\\": \\\"historical\\\"})\\n params.update({\\\"opt_endpoint\\\": opt_endpoint})\\n params.update({\\\"start_time\\\": start_time})\\n params.update({\\\"end_time\\\": end_time})\\n params.update({\\\"timestamp_key\\\": timestamp_key})\\n\\n records = params['limit']\\n offset = 1\\n while (records == params['limit']):\\n helper.log_debug(\\\"current_offset: {}\\\".format(offset))\\n params['offset'] = offset\\n records = fetch_webex_logs(ew, helper, params)\\n helper.log_debug(\\\"\\\\t Offet:{}\\\\tLimit: {}\\\\tRecords Returned: {}\\\".format(\\n offset, params['limit'], records))\\n if records:\\n offset += records\",\n \"def get_queryset(self):\\n day = self.request.query_params.get('day',None)\\n tz = pytz.timezone('Europe/London') \\n dt_now = datetime.now(tz=tz) - timedelta(minutes=10) \\n day_name_today = dt_now.strftime(\\\"%A\\\")\\n queryset = OnlineMeeting.objects.annotate(search=SearchVector('description','title'),)\\n queryset = queryset.filter(published=True)\\n\\n search = self.request.query_params.get('search', None)\\n\\n if search is not None and len(search) > 0:\\n queryset = queryset.filter(search=search)\\n\\n now = self.request.query_params.get('now',None)\\n top = int(self.request.query_params.get('top',0))\\n if day=='now':\\n \\n \\n date_today = dt_now.date()\\n time_now = dt_now.time()\\n datetime_now = datetime.combine(date_today,time_now)\\n \\n tomorrow = dt_now + timedelta(days=1) \\n day_name_tomorrow = tomorrow.strftime(\\\"%A\\\")\\n \\n meetings_today = OnlineMeeting.objects.filter(((Q(day=day_name_today) | Q(day='All')) & Q(time__gte=dt_now.time())))#.order_by('time')\\n meetings_tomorrow = OnlineMeeting.objects.filter((Q(day=day_name_tomorrow) & Q(time__lte=dt_now.time())))#.order_by('time')\\n \\n\\n all = meetings_today #| meetings_tomorrow\\n if day_name_today == 'sunday':\\n all_ordered = all.order_by('time')\\n else:\\n all_ordered = all.order_by('time')\\n \\n if top:\\n all_ordered = all_ordered[:top]\\n return all_ordered#.annotate(the_rank=rank_by_day)\\n elif day in ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']:\\n queryset = queryset.filter(Q(day=day) | Q(day='All') )\\n \\n \\n \\n \\n \\n return queryset.order_by('time')\",\n \"def dmd_metric_filter_query(self): \\n \\n metric_filter_query = \\\"\\\"\\\"\\n , elig_device_metrics as (\\n -- For eligible devices, pull their whole history for the metric we want to filter\\n SELECT \\n d.device_id,\\n d.device_first_seen_ts,\\n d.device_first_view_ts,\\n d.platform,\\n d.platform_type,\\n d.ds,\\n -- For filtering devices\\n sum({cumul_filter_metric}) as daily_filter_metric\\n FROM tubidw.device_metric_daily as d\\n JOIN pre_approved_devices as p\\n ON d.device_id = p.device_id\\n GROUP BY 1,2,3,4,5,6\\n )\\n\\n , elig_device_cumul_filter as (\\n SELECT *, sum(daily_filter_metric) OVER (PARTITION BY device_id, platform_type, platform ORDER BY ds rows between unbounded preceding and current row) as cumul_filter_metric\\n FROM elig_device_metrics\\n )\\n\\n , elig_devices as (\\n SELECT device_id\\n FROM elig_device_cumul_filter\\n GROUP BY 1\\n HAVING 1=1\\n -- cumulative metric filters dynamically populate below \\n {metric_filter_having}\\n -- example: \\n -- AND max(cumul_filter_metric) >= 3600.0 -- at least 60 mins of cumulative TVT\\n -- AND max(cumul_filter_metric) <= 3600.0 -- less than 60 mins of cumulative TVT\\n )\\n \\\"\\\"\\\"\\n return metric_filter_query\",\n \"def get_filtered_data(device_code, start_date = None, end_date=None, frequency = 'daily', pollutant = 'PM 2.5'):\\r\\n \\r\\n \\r\\n if start_date == None:\\r\\n start = str_to_date_find('2019-06-01T00:00:00Z')\\r\\n else:\\r\\n start = str_to_date(start_date)\\r\\n if end_date == None:\\r\\n end = datetime.now()\\r\\n else:\\r\\n end = str_to_date(end_date)\\r\\n \\r\\n query = { 'deviceCode': device_code, 'time': {'$lte': end, '$gte': start} }\\r\\n \\r\\n if pollutant == 'PM 10':\\r\\n projection = { '_id': 0, 'time': 1, 'characteristics.pm10ConcMass.value':1 }\\r\\n if frequency =='hourly':\\r\\n records = list(db.device_hourly_measurements.find(query, projection))\\r\\n elif frequency=='daily':\\r\\n records = list(db.device_daily_measurements.find(query, projection))\\r\\n else:\\r\\n records = list(db.device_raw_measurements.find(query, projection))\\r\\n for i in range(len(records)):\\r\\n if records[i]['characteristics']['pm10ConcMass']['value'] >0 and records[i]['characteristics']['pm10ConcMass']['value'] <=54:\\r\\n records[i]['backgroundColor'] = 'green'\\r\\n elif records[i]['characteristics']['pm10ConcMass']['value'] >54 and records[i]['characteristics']['pm10ConcMass']['value'] <=154:\\r\\n records[i]['backgroundColor'] = 'yellow'\\r\\n elif records[i]['characteristics']['pm10ConcMass']['value'] > 154 and records[i]['characteristics']['pm10ConcMass']['value'] <= 254:\\r\\n records[i]['backgroundColor'] = 'orange'\\r\\n elif records[i]['characteristics']['pm10ConcMass']['value'] > 254 and records[i]['characteristics']['pm10ConcMass']['value'] <= 354:\\r\\n records[i]['backgroundColor'] = 'red'\\r\\n elif records[i]['characteristics']['pm10ConcMass']['value'] > 354 and records[i]['characteristics']['pm10ConcMass']['value'] <= 424:\\r\\n records[i]['backgroundColor'] = 'purple'\\r\\n elif records[i]['characteristics']['pm10ConcMass']['value'] > 424 and records[i]['characteristics']['pm10ConcMass']['value'] <=604:\\r\\n records[i]['backgroundColor'] = 'maroon'\\r\\n else:\\r\\n records[i]['backgroundColor'] = 'gray'\\r\\n return records\\r\\n elif pollutant == 'NO2':\\r\\n projection = { '_id': 0, 'time': 1, 'characteristics.no2Conc.value':1 }\\r\\n if frequency =='hourly':\\r\\n records = list(db.device_hourly_measurements.find(query, projection))\\r\\n elif frequency=='daily':\\r\\n records = list(db.device_daily_measurements.find(query, projection))\\r\\n else:\\r\\n records = list(db.device_raw_measurements.find(query, projection))\\r\\n for i in range(len(records)):\\r\\n if records[i]['characteristics']['no2Conc']['value'] >0.0 and records[i]['characteristics']['no2Conc']['value'] <=53:\\r\\n records[i]['backgroundColor'] = 'green'\\r\\n elif records[i]['characteristics']['no2Conc']['value'] > 53 and records[i]['characteristics']['no2Conc']['value'] <=100:\\r\\n records[i]['backgroundColor'] = 'yellow'\\r\\n elif records[i]['characteristics']['no2Conc']['value'] > 100 and records[i]['characteristics']['no2Conc']['value'] <= 360:\\r\\n records[i]['backgroundColor'] = 'orange'\\r\\n elif records[i]['characteristics']['no2Conc']['value'] > 360 and records[i]['characteristics']['no2Conc']['value'] <= 649:\\r\\n records[i]['backgroundColor'] = 'red'\\r\\n elif records[i]['characteristics']['no2Conc']['value'] > 649 and records[i]['characteristics']['no2Conc']['value'] <= 1249:\\r\\n records[i]['backgroundColor'] = 'purple'\\r\\n elif records[i]['characteristics']['no2Conc']['value'] > 1249 and records[i]['characteristics']['no2Conc']['value'] <=2049:\\r\\n records[i]['backgroundColor'] = 'maroon'\\r\\n else:\\r\\n records[i]['backgroundColor'] = 'gray'\\r\\n return records\\r\\n else:\\r\\n projection = { '_id': 0, 'time': 1, 'characteristics.pm2_5ConcMass.value':1 }\\r\\n if frequency =='hourly':\\r\\n records = list(db.device_hourly_measurements.find(query, projection))\\r\\n elif frequency=='daily':\\r\\n records = list(db.device_daily_measurements.find(query, projection))\\r\\n else:\\r\\n records = list(db.device_raw_measurements.find(query, projection))\\r\\n for i in range(len(records)):\\r\\n if records[i]['characteristics']['pm2_5ConcMass']['value'] >0.0 and records[i]['characteristics']['pm2_5ConcMass']['value'] <=12.0:\\r\\n records[i]['backgroundColor'] = 'green'\\r\\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] >12.0 and records[i]['characteristics']['pm2_5ConcMass']['value'] <=35.4:\\r\\n records[i]['backgroundColor'] = 'yellow'\\r\\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] > 35.4 and records[i]['characteristics']['pm2_5ConcMass']['value'] <= 55.4:\\r\\n records[i]['backgroundColor'] = 'orange'\\r\\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] > 55.4 and records[i]['characteristics']['pm2_5ConcMass']['value'] <= 150.4:\\r\\n records[i]['backgroundColor'] = 'red'\\r\\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] > 150.4 and records[i]['characteristics']['pm2_5ConcMass']['value'] <= 250.4:\\r\\n records[i]['backgroundColor'] = 'purple'\\r\\n elif records[i]['characteristics']['pm2_5ConcMass']['value'] > 250.4 and records[i]['characteristics']['pm2_5ConcMass']['value'] <=500.4:\\r\\n records[i]['backgroundColor'] = 'maroon'\\r\\n else:\\r\\n records[i]['backgroundColor'] = 'gray'\\r\\n return records\",\n \"def _filter_data(analyzed_tweet_data: list, start_date, end_date, hashtags, mentions, urls):\\n # filter by dates\\n filtered_data = get_tweets_in_daterange(\\n analyzed_tweet_data, start_date, end_date)\\n print(\\\"Done filtering on date...\\\")\\n if hashtags:\\n filtered_data = _filter_search_values(\\n 'hashtags', hashtags, filtered_data)\\n print(f'Done filtering on hashtags: {hashtags}')\\n if mentions:\\n filtered_data = _filter_search_values(\\n 'mentions', mentions, filtered_data)\\n print(f'Done filtering on mentions: {mentions}')\\n if urls:\\n filtered_data = _filter_search_values(\\n 'tweet_urls', urls, filtered_data)\\n print(f'Done filtering on urls: {urls}')\\n\\n return filtered_data\",\n \"def data_filter(\\n df, CondTempRange=[float('-inf'), float('inf')],\\n EvapTempRange=[float('-inf'), float('inf')],\\n RemovalPoint=[OperatingPoint()],\\n AddPoint=[OperatingPoint()]\\n ):\\n\\n # copy new dataframe\\n df_new = copy.deepcopy(df)\\n\\n # condition list\\n cond = []\\n cond.append(df.CondTempInF >= CondTempRange[0])\\n cond.append(df.CondTempInF <= CondTempRange[1])\\n cond.append(df.EvapTempInF >= EvapTempRange[0])\\n cond.append(df.EvapTempInF <= EvapTempRange[1])\\n for point in RemovalPoint:\\n cond.append(df.OperatingPoint != point)\\n addcond = []\\n for point in AddPoint:\\n addcond.append(df.OperatingPoint == point)\\n\\n # Apply AND to all conditions\\n final_condition = cond[0]\\n for ii in xrange(1, len(cond)):\\n final_condition = final_condition*cond[ii]\\n\\n # Apply OR to all conditions\\n for ii in xrange(0, len(addcond)):\\n final_condition = final_condition+addcond[ii]\\n\\n # Return the data that satisfy all conditions\\n return df_new[final_condition]\",\n \"def build_query(devices, filter_inter, interactions_further=None):\\n\\n id_2_found = CsvFormat.other_id.value\\n if interactions_further is not None:\\n id_2_found = CsvFormat.my_id.value\\n\\n query = 'SELECT i._{} as id, CAST(i._{} as int) as timestamp_start, CAST(i._{} as float) as interval_time ' \\\\\\n 'FROM S3Object i WHERE CAST(i._{} as float) >= {}'.format(\\n id_2_found,\\n CsvFormat.timestamp_start.value,\\n CsvFormat.interval.value,\\n CsvFormat.interval.value,\\n MINIMUM_INTERVAL_TIME)\\n\\n if 'distance' in filter_inter:\\n if 'max' in filter_inter['distance']:\\n query += ' and CAST(i._{} as float) <= {}'.format(CsvFormat.distance_type.value,\\n filter_inter['distance']['max'])\\n if 'min' in filter_inter['distance']:\\n query += ' and CAST(i._{} as float) >= {}'.format(CsvFormat.distance_type.value,\\n filter_inter['distance']['min'])\\n\\n if interactions_further is not None:\\n condos = []\\n for inter in interactions_further:\\n orcond = '(i._{}=\\\\'{}\\\\' and (CAST(i._{} as float) between {} and {} or CAST(i._{} as float) between {} and {}))'\\\\\\n .format(CsvFormat.other_id.value,\\n inter['id'],\\n CsvFormat.timestamp_start.value,\\n inter['timestamp_start'],\\n int(inter['timestamp_start'] + inter['interval_time']),\\n CsvFormat.timestamp_end.value,\\n inter['timestamp_start'],\\n int(inter['timestamp_start'] + inter['interval_time'])\\n )\\n condos.append(orcond)\\n if len(condos) > 0:\\n query += ' and ' + ' or '.join(condos)\\n else:\\n query += ' and i._{} in (\\\\'{}\\\\')'.format(\\n CsvFormat.my_id.value,\\n '\\\\',\\\\''.join([str(x) for x in devices])\\n )\\n\\n return query\",\n \"def filter_listings(listing):\\n\\n MIN_PRICE = program_features.MIN_PRICE\\n MAX_PRICE = program_features.MAX_PRICE\\n\\n MAX_DISTANCE = program_features.MAX_DISTANCE\\n\\n MIN_NUM_ROOMS = program_features.MIN_NUM_ROOMS\\n MAX_NUM_ROOMS = program_features.MAX_NUM_ROOMS\\n\\n if (float(listing.price[1:4]) < MIN_PRICE) or (float(listing.price[1:4]) > MAX_PRICE):\\n print (\\\"Listing price = {}\\\".format(listing.price[1:4], ))\\n return False\\n elif (float(listing.distance) > MAX_DISTANCE):\\n print (\\\"Listing distance = {}\\\".format(float(listing.distance)))\\n return False\\n elif (int(listing.rooms) < MIN_NUM_ROOMS) or (int(listing.rooms) > MAX_NUM_ROOMS) :\\n print (\\\"Listing rooms = {}\\\".format(int(listing.rooms)))\\n return False\\n else:\\n return True\",\n \"def apply_search_filters():\\n params = {'api_key': API_KEY}\\n for k in demisto.args():\\n if demisto.getArg(k):\\n params['term'] = k\\n params['query'] = demisto.getArg(k)\\n break\\n return params\",\n \"def filter_dataframe(df, start_date_dt, end_date_dt):\\n\\n dff = df \\n # df[\\n # (df[\\\"timestamp\\\"].dt.date >= dt.date(start_date_dt.year, start_date_dt.month, start_date_dt.day))\\n # & (df[\\\"timestamp\\\"].dt.date <= dt.date(end_date_dt.year, end_date_dt.month, end_date_dt.day))\\n # ]\\n # if (lat_min != -90) or (lat_max != 90):\\n # dff = dff[\\n # (dff[\\\"lat\\\"] >= lat_min)\\n # & (dff[\\\"lat\\\"] <= lat_max)\\n # ]\\n # if (lon_min != -90) or (lon_max != 90):\\n # dff = dff[\\n # (dff[\\\"lon\\\"] >= lon_min)\\n # & (dff[\\\"lon\\\"] <= lon_max)\\n # ]\\n\\n return dff\",\n \"def filter_items(self, filter_data: Dict[str, str] = None) -> List[WalletItem]:\\n filtered_items = self.items\\n for key, value in filter_data.items():\\n if key == \\\"category\\\":\\n filtered_items = [item for item in filtered_items\\n if re.search(value, item.category, re.IGNORECASE)]\\n if key == \\\"account\\\":\\n filtered_items = [item for item in filtered_items\\n if re.search(value, item.account, re.IGNORECASE)]\\n if key == \\\"notes\\\" in filter_data:\\n filtered_items = [item for item in filtered_items\\n if re.search(value, item.notes, re.IGNORECASE)]\\n if key == \\\"amt_min\\\":\\n value = float(value)\\n filtered_items = [item for item in filtered_items if item.amount >= value]\\n if key == \\\"amt_max\\\":\\n value = float(value)\\n filtered_items = [item for item in filtered_items if item.amount <= value]\\n if key == \\\"begin_date\\\":\\n try:\\n begin_date = datetime.strptime(value, '%d/%m/%Y')\\n filtered_items = [item for item in filtered_items if begin_date <= item.date]\\n except ValueError as ex:\\n print(ex)\\n exit(1)\\n if key == \\\"end_date\\\":\\n try:\\n end_date = datetime.strptime(value, '%d/%m/%Y')\\n filtered_items = [item for item in filtered_items if item.date <= end_date]\\n except ValueError as ex:\\n print(ex)\\n exit(1)\\n return filtered_items\",\n \"def get_queryset(self):\\n #return Poll.objects.filter(pub_date__lte=timezone.now())\\n return Poll.objects.annotate(num_choices=Count('choice')).filter(pub_date__lte=timezone.now(), num_choices__gte=2)\",\n \"def get_filters(self):\",\n \"def add_event_filter(_filter, event_type, date_min=None):\\n\\n if event_type == 'PLANNED':\\n if date_min:\\n _filter['endDate'] = {\\n 'operation': 'greaterThanDate',\\n 'options': [{\\n 'name': 'date',\\n 'value': [date_min]\\n }]\\n }\\n else:\\n _filter['endDate'] = {\\n 'operation': '> sysdate - 2'\\n }\\n _filter['startDate'] = {\\n 'operation': 'orderBy',\\n 'options': [{\\n 'name': 'sort',\\n 'value': ['DESC']\\n }]\\n }\\n\\n if event_type == 'UNPLANNED_INCIDENT':\\n if date_min:\\n _filter['modifyDate'] = {\\n 'operation': 'greaterThanDate',\\n 'options': [{\\n 'name': 'date',\\n 'value': [date_min]\\n }]\\n }\\n else:\\n _filter['modifyDate'] = {\\n 'operation': '> sysdate - 2'\\n }\\n\\n if event_type == 'ANNOUNCEMENT':\\n _filter['statusCode'] = {\\n 'keyName': {\\n 'operation': 'in',\\n 'options': [{\\n 'name': 'data',\\n 'value': ['PUBLISHED']\\n }]\\n }\\n }\",\n \"def filter_dt(tp,ts, show_plot, lower_delta,min_len):\\n import numpy\\n import matplotlib.pyplot as plt\\n ####################################\\n def array_none_removal(array_dt):\\n output=[]\\n for index in range(len(array_dt)):\\n if array_dt[index]!=None:\\n output.append(array_dt[index])\\n return(output)\\n \\n ####################################\\n # Calculate delta t based in P and S1 arrival\\n delta_t=[]\\n for gph_index in range(len(tp)):\\n # verify is the pp and sp1 are NOT nan\\n if tp[gph_index]!=None and ts[gph_index]!=None:\\n #if (not math.isnan(tp[gph_index])) and (not math.isnan(ts[gph_index])):\\n delta_t.append(ts[gph_index]-tp[gph_index])\\n else:\\n delta_t.append(None)\\n\\n ####################################\\n #%% Filter delta_t\\n \\n # Remove Nones from delta t to calculate its stats\\n dt_numbers=array_none_removal(delta_t)\\n dt_numbers=list(filter(lambda x:x>0.25, dt_numbers)) # remove values lower than 0.2\\n \\n # Build the new delta_t array with outliers removed\\n dt_filtered=[]\\n \\n for dt_index in range(len(delta_t)):\\n if delta_t[dt_index]!= None:\\n if delta_t[dt_index] <= (numpy.median(dt_numbers)+numpy.std(dt_numbers)) and delta_t[dt_index] >= (numpy.median(dt_numbers)-numpy.std(dt_numbers)) and delta_t[dt_index]>=lower_delta:\\n dt_filtered.append(delta_t[dt_index])\\n else:\\n dt_filtered.append(None)\\n else:\\n dt_filtered.append(None)\\n \\n dt_filtered_numbers=array_none_removal(dt_filtered)\\n #print('Len filtered ',len(dt_filtered_numbers))\\n \\n ####################################\\n if show_plot==True:# and len(dt_filtered_numbers)>=min_len: \\n plt.figure(1, figsize=(8,1))\\n plt.plot(dt_filtered,'.k')\\n plt.axhline(y=numpy.median(dt_numbers),c='g', linestyle='--')#, lw=0.5)\\n plt.axhline(y=numpy.median(dt_numbers)+numpy.std(dt_numbers),c='r', linestyle=':')#, lw=0.5)\\n plt.axhline(y=numpy.median(dt_numbers)-numpy.std(dt_numbers),c='r', linestyle=':')#,lw=0.5)\\n plt.ylim(0.5,1.5)\\n plt.xlabel('Gph id')\\n plt.ylabel('ts -tp (s)')\\n plt.title('ATP ts-tp') \\n plt.show()\\n plt.close()\\n #################################### \\n return(dt_filtered,dt_filtered_numbers)\",\n \"def queryset(self, request):\\n qs = super(AdRepConsumerAdmin, self).queryset(request)\\n qs = AdRepConsumer.objects.select_related().filter(id__in=qs\\n ).defer('consumer__site__envelope',\\n 'consumer__site__geom',\\n 'consumer__site__point')\\n return qs\",\n \"def queryset(self, request, queryset):\\n if self.value() == 'syndicated':\\n return queryset.filter(syndicated_at__isnull=False)\\n if self.value() == 'ready_to_syndicate':\\n return queryset.filter(ignored_at=None,\\n syndicated_at=None,\\n longitude_position__isnull=False,\\n merchantwebsite__deleted_at=None,\\n merchantdoc__deleted_at=None,\\n ).distinct()\\n if self.value() == 'ignore':\\n return queryset.filter(ignored_at__isnull=False)\",\n \"def _query_builder(self,\\n start_date=None,\\n end_date=None,\\n clipper=None\\n ):\\n search_string='format=json&lang=fr&q='\\n if (start_date is not None):\\n if(end_date is not None):\\n search_string+='entre+'+start_date+'+et+'+end_date\\n else:\\n search_string+=start_date\\n elif(end_date is not None): \\n search_string+=end_date\\n \\n if(clipper.query is not None):\\n query=clipper.query.replace(' ','+')\\n search_string+='+'+query\\n if(clipper.bbox is not None):\\n search_string+='&box='+clipper.bbox\\n\\n return search_string\",\n \"def filter_geomag(inst, min_kp=0, max_kp=9, filter_time=24, kp_inst=None):\\n # Load the desired data\\n if kp_inst is None:\\n kp_inst = pysat.Instrument(inst_module=pysat_sw.instruments.sw_kp,\\n tag='', pad=pds.DateOffset(days=1))\\n\\n if kp_inst.empty:\\n kp_inst.load(date=inst.date, verifyPad=True)\\n\\n # Begin filtering, starting at the beginning of the instrument data\\n sel_data = kp_inst[(inst.date - pds.DateOffset(days=1)):\\n (inst.date + pds.DateOffset(days=1))]\\n ind, = np.where((sel_data['Kp'] > max_kp) | (sel_data['Kp'] < min_kp))\\n for lind in ind:\\n sind = sel_data.index[lind]\\n eind = sind + pds.DateOffset(hours=filter_time)\\n inst[sind:eind] = np.nan\\n inst.data = inst.data.dropna(axis=0, how='all')\\n\\n return\",\n \"def solve_filter_time_interval(self):\\n if 'interval' in self.filter_request:\\n temp_list_pack = []\\n temp_list_pack.append(self.list_pack[0])\\n curr_time = pandas.to_datetime(self.list_pack[0]['time_stamp'])\\n filter_interval = int(self.filter_request['interval'])\\n\\n if filter_interval <= 0:\\n filter_interval = int(1)\\n\\n for i in self.list_pack:\\n pack_time = pandas.to_datetime(i['time_stamp'])\\n if (curr_time + pandas.to_timedelta(filter_interval, unit='s')) <= pack_time:\\n temp_list_pack.append(i)\\n curr_time = pandas.to_datetime(i['time_stamp'])\\n\\n self.list_pack = temp_list_pack\",\n \"def apply_20percent_shipping_offer(self):\\n product_range = Range.objects.create(\\n name=\\\"All products range\\\", includes_all_products=True\\n )\\n benefit = Benefit.objects.create(\\n range=product_range, type=Benefit.SHIPPING_PERCENTAGE, value=20\\n )\\n offer = factories.create_offer(product_range=product_range, benefit=benefit)\\n Applicator().apply_offers(self.basket, [offer])\\n return offer\",\n \"def og_features(scan,filt=None,base_noise=None,thresh=-1.4781e-10,diff=1,verbose=False,scale=10):\\n #get gradients of data\\n der = np.array(np.gradient(scan,diff))\\n \\n #calculate gardient magnitudes and directions\\n der_mag = np.linalg.norm(der,axis=0) \\n der_uvecs = der/der_mag\\n \\n z_cur = np.copy(scan).ravel()\\n\\n #estimate noise level and set derivative filter threshold\\n if filt is None:\\n filt = np.mean(signaltonoise(der_mag)[-1])\\n \\n \\n if base_noise is not None:\\n filt = np.maximum(filt,base_noise)\\n \\n\\n\\n #filter directions and magnitudes\\n x, y, z = der_uvecs[0].ravel(), der_uvecs[1].ravel(), der_mag.ravel()\\n \\n #filter using threshold and filt\\n x_filt, y_filt, z_filt = x[z_cur>thresh], y[z_cur>thresh], z[z_cur>thresh]\\n #x_filt, y_filt, z_filt = x, y, z\\n\\n \\n #print(len(z_filt))\\n x_filt, y_filt, z_filt = x_filt[z_filt>filt], y_filt[z_filt>filt], z_filt[z_filt>filt]\\n\\n \\n #calculate angles\\n angles_filt = np.sign(y_filt)*np.arccos(x_filt/1)\\n\\n \\n #print(len(angles_filt))\\n \\n if len(angles_filt) < 2:\\n return 0,0,0\\n \\n #fit single line\\n sol1 = least_squares(ress_1line,[-np.pi/2],args=(angles_filt,),bounds=[-np.pi,0],method='dogbox',jac='2-point',max_nfev=2000)\\n\\n #fit two lines by grid search\\n #sol_grid = grid_search(ress_2line,angles_filt,[[-np.pi,0],[-np.pi,0]])\\n \\n \\n singleline = sol1.x[0]\\n \\n mx = np.minimum(np.abs(singleline-(-np.pi)),np.abs(singleline))\\n \\n sol_grid = grid_search(ress_2line_pm,angles_filt,[[0,mx]],umid = singleline)\\n spread_lines = sol_grid[1]\\n sol_grid[1] = [singleline+spread_lines,singleline-spread_lines]\\n \\n \\n #compute average of squared residuals for both cases\\n resid1 = ress_1line(sol1.x,angles_filt)\\n\\n grid_c11 = np.average(np.power(resid1,2))\\n \\n grid_c11 = np.average(np.abs(resid1))\\n \\n grid_c21 = sol_grid[-1]\\n \\n \\n multip = cotunnel_score2(scan,scan>thresh,diff,scale)\\n \\n final_grid2 = multip*(grid_c11-grid_c21)\\n \\n \\n \\\"\\\"\\\"\\n plt.scatter(angles_filt,z_filt,marker='x',c='k',s=15,linewidth=0.4)\\n plt.axvline(sol1.x,color='b')\\n plt.axvline(sol1.x+(np.pi),color='b')\\n plt.axvline(sol_grid[1][0],0,color='r', linestyle='--')\\n plt.axvline(sol_grid[1][1],0,color='r', linestyle='--')\\n \\n plt.axvline(sol_grid[1][0]+(np.pi),0,color='r', linestyle='--')\\n plt.axvline(sol_grid[1][1]+(np.pi),0,color='r', linestyle='--')\\n \\n plt.xlabel(\\\"$\\\\\\\\theta_g$ / rad\\\")\\n \\n plt.xlim([-np.pi,np.pi])\\n plt.ylim([0,z.max()])\\n \\n \\n plt.ylabel(\\\"$|g|$\\\")\\n \\n plt.xticks([-np.pi,0,np.pi])\\n \\n plt.locator_params(axis='y', nbins=2)\\n \\n plt.savefig(\\\"og_fig.svg\\\")\\n \\n plt.show()\\n \\\"\\\"\\\"\\n return final_grid2,multip,(grid_c11-grid_c21)\",\n \"def _make_query_result(self, cr , uid, data, context=None):\\n search_criterea = ''\\n #Date Wise Bifurcation\\n if data.type == 'date':\\n start = data.start_date\\n end = data.end_date\\n if start and end:\\n start = self.date_to_datetime(cr, uid, start + ' 00:00:00', context=context)\\n end = self.date_to_datetime(cr, uid, end + ' 23:59:59', context=context)\\n search_criterea += \\\" AND mp.date_planned > '\\\" + str(start) + \\\"' AND mp.date_finished < '\\\" + str(end) + \\\"' \\\"\\n elif start:\\n start = self.date_to_datetime(cr, uid, start + ' 00:00:00', context=context)\\n search_criterea += \\\" AND mp.date_planned > '\\\" + str(start) + \\\"' \\\"\\n elif end:\\n end = self.date_to_datetime(cr, uid, end + ' 23:59:59', context=context)\\n search_criterea += \\\" AND mp.date_finished < '\\\" + str(end) + \\\"' \\\"\\n else:\\n #Number Wise Bifurcation\\n number_from = data.number_from\\n number_to = data.number_to\\n if number_from <= 0 or number_to <= 0:\\n raise osv.except_osv(_('Warning!'), _('Negative or Zero number not allow to pass!'))\\n if number_from > 0 and number_to > 0:\\n if number_from > number_to:\\n raise osv.except_osv(_('Warning!'), _('Please correct the number place.\\\\nNumber To must be greater then Number From.'))\\n count, comma = 0, True\\n if number_from == number_to:\\n comma = False\\n for r in range(number_from, number_to + 1):\\n count += 1\\n if count == 1: search_criterea += \\\" AND mp.name SIMILAR TO '%(\\\"\\n search_criterea += str(r)\\n if comma and (r <> number_to): search_criterea += '|'\\n if r == number_to: search_criterea += \\\")%'\\\"\\n #State Wise Bifurcation\\n if data.draft or data.in_production or data.ready or data.done or data.cancel or data.confirmed or data.picking_except:\\n if not search_criterea: search_criterea += ' AND mp.state in ('\\n else:\\n search_criterea += ' AND mp.state in ('\\n j_s = ''\\n if data.draft: j_s += \\\"'draft',\\\"\\n if data.in_production: j_s += \\\"'in_production',\\\"\\n if data.ready: j_s += \\\"'ready',\\\"\\n if data.done: j_s += \\\"'done',\\\"\\n if data.cancel: j_s += \\\"'cancel',\\\"\\n if data.confirmed: j_s += \\\"'confirmed',\\\"\\n if data.picking_except: j_s += \\\"'picking_except',\\\"\\n search_criterea += j_s[:-1]+')'\\n if search_criterea: search_criterea = ' WHERE mpwl.production_id = mp.id ' + search_criterea\\n #Merged this query criterea for execution\\n cr.execute(\\\"\\\"\\\" SELECT mpwl.id FROM mrp_production mp, mrp_production_workcenter_line mpwl \\\"\\\"\\\"+ search_criterea)\\n return [r[0] for r in cr.fetchall()]\",\n \"def get_filtered_dataX(device_code, start_date = None, end_date=None, frequency = 'daily', pollutant = 'PM 2.5'):\\r\\n if start_date == None:\\r\\n start = str_to_date_find('2019-06-01T00:00:00Z')\\r\\n else:\\r\\n start = str_to_date(start_date)\\r\\n if end_date == None:\\r\\n end = datetime.now()\\r\\n else:\\r\\n\\r\\n end = str_to_date(end_date)\\r\\n\\r\\n query = {'$match':{ 'deviceCode': device_code, 'time': {'$lte': end, '$gte': start} }}\\r\\n \\r\\n if pollutant == 'PM 10': \\r\\n projection = { '$project': { '_id': 0, \\r\\n 'time': {'$dateToString':{ 'format': '%Y-%m-%dT%H:%M:%S%z', 'date': '$time', 'timezone':'Africa/Kampala'}}, \\r\\n 'pollutant_value': {'$round':['$characteristics.pm10ConcMass.value',2]} }}\\r\\n elif pollutant == 'NO2': \\r\\n projection = { '$project': { '_id': 0, \\r\\n 'time': {'$dateToString':{ 'format': '%Y-%m-%dT%H:%M:%S%z', 'date': '$time', 'timezone':'Africa/Kampala'}}, \\r\\n 'pollutant_value': {'$round':['$characteristics.no2Conc.value',2]} }} \\r\\n else: \\r\\n projection = { '$project': { '_id': 0, \\r\\n 'time': {'$dateToString':{ 'format': '%Y-%m-%dT%H:%M:%S%z', 'date': '$time', 'timezone':'Africa/Kampala'}}, \\r\\n 'pollutant_value': {'$round':['$characteristics.pm2_5ConcMass.value',2]} }} \\r\\n \\r\\n \\r\\n if frequency =='hourly':\\r\\n records = db.device_hourly_measurements.aggregate([query, projection]) \\r\\n elif frequency == 'monthly':\\r\\n results = list(db.device_daily_measurements.aggregate([query, projection]))\\r\\n records = resample_timeseries_data(results, 'M', 'time', 2)\\r\\n else:\\r\\n records = db.device_daily_measurements.aggregate([query, projection])\\r\\n\\r\\n \\r\\n return list(records)\",\n \"def daily_search(term, state='', property=''):\\n geo = \\\"\\\"\\n if state == '':\\n geo = state = 'US'\\n else:\\n geo = 'US-' + state\\n\\n out = service.getGraph(terms=term,\\n restrictions_startDate='2008-01',\\n restrictions_endDate='2008-07',\\n restrictions_geo=geo,\\n restrictions_property=property).execute().get('lines')[0].get('points')\\n\\n next = service.getGraph(terms=term,\\n restrictions_startDate='2008-07',\\n restrictions_endDate='2009-01',\\n restrictions_geo=geo,\\n restrictions_property=property).execute().get('lines')[0].get('points')\\n\\n #out['orig_value'] = out['value']\\n #next['orig_value'] = next['value']\\n\\n multiplier = 1\\n if next[30].get('value') != 0:\\n multiplier = out[-1].get('value')/next[30].get('value')\\n if multiplier == 0:\\n multiplier = 1\\n\\n for i in next:\\n i['value'] = i['value']*multiplier\\n\\n out = out + next[31:]\\n\\n for i in range(2009,2019):\\n print(term + ', ' + property + ', ' + str(i))\\n n = i + 1\\n for j in range(1,3):\\n if j == 1:\\n s = str(i) + '-01'\\n e = str(i) + '-07'\\n else:\\n s = str(i) + '-07'\\n e = str(i + 1) + '-01'\\n\\n next = service.getGraph(terms=term,\\n restrictions_startDate=s,\\n restrictions_endDate=e,\\n restrictions_geo=geo,\\n restrictions_property=property).execute().get('lines')[0].get('points')\\n\\n #next['orig_value'] = next['value']\\n\\n multiplier = 1\\n if next[30].get('value') != 0:\\n multiplier = out[-1].get('value')/next[30].get('value')\\n if multiplier == 0:\\n multiplier = 1\\n\\n for k in next:\\n k['value'] = k['value']*multiplier\\n\\n out = out + next[31:]\\n\\n\\n\\n\\n if property == '':\\n property = 'web'\\n\\n df1 = pd.DataFrame(out)\\n\\n df1['term'] = term\\n df1['state'] = state\\n df1['property'] = property\\n\\n return df1\",\n \"def accepted_query_params(self):\\n # date range related.\\n days_range = arrow.Arrow.range(\\\"day\\\",\\n ArrowParameter.get(self.date_begin),\\n ArrowParameter.get(self.date_end))\\n accepted_date_values = sorted(map(str, days_range))\\n\\n # result\\n return {\\n \\\"date_value\\\": accepted_date_values,\\n \\\"task_cls\\\": self.ptm.task_class_names,\\n \\\"luiti_package\\\": self.ptm.task_package_names,\\n }\",\n \"def filter_on_adwin_parameters(a_lt3,a_lt4,**kw):\\r\\n\\r\\n filter_params = kw.pop('adwin_filter_params',{})\\r\\n if len(filter_params):\\r\\n old_params = analysis_params.SPSP_fltr_adwin_settings\\r\\n \\r\\n for setup_key,setup_dict in filter_params.iteritems():\\r\\n for key,params in setup_dict.iteritems():\\r\\n analysis_params.SPSP_fltr_adwin_settings['fltr_dict_'+setup_key][key] = params\\r\\n\\r\\n fltr = np.array([True]*len(a_lt3.agrp['ssro_results'].value)) ### initially everything true\\r\\n\\r\\n for a,suffix in zip([a_lt3,a_lt4],['lt3','lt4']): ### loop over both files\\r\\n for key,val in analysis_params.SPSP_fltr_adwin_settings['fltr_dict_'+suffix].iteritems(): ### loop over the list of filter parameters\\r\\n [filter_on,minimum,maximum] = val\\r\\n\\r\\n if filter_on:\\r\\n if key == 'repetition_number':\\r\\n values = np.array([i for i in range(len(fltr)/a.g.attrs['sweep_length']) for _ in range(a.g.attrs['sweep_length'])]) ### Make an array of values corresponding to the current rep\\r\\n else:\\r\\n values = a.agrp[key].value\\r\\n\\r\\n fltr = np.logical_and(fltr,(values >= minimum) & ( values <= maximum)) ### update filter\\r\\n\\r\\n if len(filter_params):\\r\\n analysis_params.SPSP_fltr_adwin_settings = old_params\\r\\n\\r\\n return fltr\",\n \"def amh_attr_filter_query(self):\\n \\n attr_filter_query = \\\"\\\"\\\"\\n WITH {final_cte_name} as (\\n -- Pull list of devices that were active (has any row; don't need TVT >0) in the past 4 weeks\\n SELECT DISTINCT device_id\\n FROM tubidw.all_metric_hourly\\n WHERE DATE_TRUNC('week',hs) >= dateadd('week',-4,DATE_TRUNC('week',GETDATE()))\\n AND DATE_TRUNC('week',hs) < DATE_TRUNC('week',GETDATE())\\n {attr_filter} -- attribute filters dynamically populate here\\n -- TODO: currently can't get a metric/attribute combo filter, like \\\"devices that watched at least 50% of a specific content_id\\\"\\n )\\n \\\"\\\"\\\"\\n return attr_filter_query\",\n \"def premium_set_search_params(self, search_query, from_date, to_date,\\n no_retweets=True, results_per_call=500):\\n \\n # Set a static Language Filter for English Tweets\\n lang_filter = ' lang:en'\\n if no_retweets:\\n rt_filter = ' -is:retweet'\\n # Adds an ignore Retweets tag to the (Altcoin) Query\\n self.query = search_query + lang_filter + rt_filter\\n else:\\n # This Query includes all Tweets, also Retweets\\n self.query = search_query + lang_filter\\n # Sets the Rule for the Query to be executed (time frame & # of Results)\\n self.rule = gen_rule_payload(self.query, results_per_call=results_per_call,\\n from_date=from_date, to_date=to_date)\",\n \"def suggest_similar_activities(self, *, elev_gain=None, distance=None, dist_fudge=0.1, elev_fudge=0.1, metric=False, activity_type=\\\"Ride\\\", open_web=False) :\\n\\n # You need to have at least one of elevation gain and distance.\\n if elev_gain == None and distance == None :\\n raise ValueError(\\\"elev_gain and distance can't both equal None.\\\")\\n\\n csv_file = activity_type + \\\".csv\\\"\\n try:\\n actDF = pd.read_csv(csv_file, index_col=\\\"id\\\", parse_dates=[\\\"start_date\\\", \\\"start_date_local\\\"])\\n except FileNotFoundError:\\n print(csv_file, \\\"file does not exist. Record some of that activity and try again.\\\")\\n else:\\n # Sort out what units we're using.\\n if not metric :\\n dist_key = \\\"distance(miles)\\\"\\n elev_gain_key = \\\"elevation_gain(ft)\\\"\\n dist_units = \\\"miles\\\"\\n elev_units = \\\"feet\\\"\\n else:\\n dist_key = \\\"distance(km)\\\"\\n elev_gain_key = \\\"total_elevation_gain\\\"\\n dist_units = \\\"km\\\"\\n elev_units = \\\"meters\\\"\\n\\n # Deal with three situations: We have elevation gain and distance. We have\\n # elevation but not distance. We have distance but not elevation.\\n # We don't need to test if both are None because\\n # we did that above.\\n if elev_gain and distance :\\n similarDF = actDF[ (actDF[dist_key] >= distance - dist_fudge*distance) & (actDF[dist_key] <= distance + dist_fudge*distance) & (actDF[elev_gain_key] >= elev_gain - elev_fudge*elev_gain) & (actDF[elev_gain_key] <= elev_gain + elev_fudge*elev_gain) ]\\n print(\\\"\\\\nActivities with elevation gain similar to\\\", elev_gain, elev_units, \\\"and distance similar to\\\", distance, dist_units, \\\":\\\\n\\\")\\n elif not distance :\\n similarDF = actDF[ (actDF[elev_gain_key] >= elev_gain - elev_fudge*elev_gain) & (actDF[elev_gain_key] <= elev_gain + elev_fudge*elev_gain) ]\\n print(\\\"Activities with elevation gain similar to\\\", elev_gain, elev_units, \\\":\\\")\\n elif not elev_gain:\\n similarDF = actDF[ (actDF[dist_key] >= distance - dist_fudge*distance) & (actDF[dist_key] <= distance + dist_fudge*distance) ]\\n print(\\\"Activities with distance similar to\\\", distance, dist_units,\\\":\\\")\\n\\n list_of_urls = []\\n if len(similarDF) > 0 :\\n for i in similarDF.index:\\n act_url = \\\"https://www.strava.com/activities/\\\" + str(i)\\n # new\\n if open_web :\\n webbrowser.open_new_tab(act_url)\\n list_of_urls.append(act_url)\\n print(similarDF.loc[i, \\\"name\\\"], f'{similarDF.loc[i,dist_key]:.2f}', dist_units, f'{similarDF.loc[i,elev_gain_key]:.2f}', elev_units)\\n print(act_url + \\\"\\\\n\\\")\\n else:\\n print(\\\"No activities with elevation gain similar to \\\", elev_gain, \\\"and distance similar to\\\", distance)\\n return list_of_urls\",\n \"def get_options_data(self, from_date, to_date, range=\\\"None\\\"):\\n base_url = 'https://api.tdameritrade.com/v1/marketdata/chains?&symbol={stock_ticker}&fromDate={startdate}&toDate={enddate}&range={range}'\\n endpoint = base_url.format(stock_ticker=self.ticker, startdate=from_date, enddate=to_date, range=range)\\n\\n page = requests.get(url=endpoint, params={'apikey': self.key})\\n time.sleep(1)\\n content = json.loads(page.content)\\n\\n call_options = pd.DataFrame()\\n put_options = pd.DataFrame()\\n\\n if content[\\\"putExpDateMap\\\"] and content[\\\"callExpDateMap\\\"]:\\n for date in content[\\\"callExpDateMap\\\"]:\\n for strike in content[\\\"callExpDateMap\\\"][date]:\\n for data in content[\\\"callExpDateMap\\\"][date][strike]:\\n call_options = call_options.append({\\n 'strikePrice': data[\\\"strikePrice\\\"],\\n 'expirationDate': data[\\\"expirationDate\\\"],\\n 'daysToExpiration': data[\\\"daysToExpiration\\\"],\\n 'call': data[\\\"putCall\\\"],\\n 'call_bid': data[\\\"bid\\\"],\\n 'call_ask': data[\\\"ask\\\"],\\n 'call_last': data[\\\"last\\\"],\\n 'call_mark': data[\\\"mark\\\"],\\n 'call_bidSize': data[\\\"bidSize\\\"],\\n 'call_askSize': data[\\\"askSize\\\"],\\n 'call_bidAskSize': data[\\\"bidAskSize\\\"],\\n 'call_lastSize': data[\\\"lastSize\\\"],\\n 'call_highPrice': data[\\\"highPrice\\\"],\\n 'call_lowPrice': data[\\\"lowPrice\\\"],\\n 'call_openPrice': data[\\\"openPrice\\\"],\\n 'call_closePrice': data[\\\"closePrice\\\"],\\n 'call_totalVolume': data[\\\"totalVolume\\\"],\\n 'call_tradeDate': data[\\\"tradeDate\\\"],\\n 'call_tradeTimeInLong': data[\\\"tradeTimeInLong\\\"],\\n 'call_quoteTimeInLong': data[\\\"quoteTimeInLong\\\"],\\n 'call_netChange': data[\\\"netChange\\\"],\\n 'call_volatility': data[\\\"volatility\\\"],\\n 'call_delta': data[\\\"delta\\\"],\\n 'call_gamma': data[\\\"gamma\\\"],\\n 'call_theta': data[\\\"theta\\\"],\\n 'call_vega': data[\\\"vega\\\"],\\n 'call_rho': data[\\\"rho\\\"],\\n 'call_openInterest': data[\\\"openInterest\\\"],\\n 'call_timeValue': data[\\\"timeValue\\\"],\\n 'call_theoreticalOptionValue': data[\\\"theoreticalOptionValue\\\"],\\n 'call_theoreticalVolatility': data[\\\"theoreticalVolatility\\\"],\\n 'call_optionDeliverablesList': data[\\\"optionDeliverablesList\\\"],\\n 'call_expirationType': data[\\\"expirationType\\\"],\\n 'call_lastTradingDay': data[\\\"lastTradingDay\\\"],\\n 'call_multiplier': data[\\\"multiplier\\\"],\\n 'call_percentChange': data[\\\"percentChange\\\"],\\n 'call_markChange': data[\\\"markChange\\\"],\\n 'call_markPercentChange': data[\\\"markPercentChange\\\"]},\\n ignore_index=True)\\n\\n for date in content[\\\"putExpDateMap\\\"]:\\n for strike in content[\\\"putExpDateMap\\\"][date]:\\n for data in content[\\\"putExpDateMap\\\"][date][strike]:\\n put_options = put_options.append({\\n 'strikePrice': data[\\\"strikePrice\\\"],\\n 'expirationDate': data[\\\"expirationDate\\\"],\\n 'daysToExpiration': data[\\\"daysToExpiration\\\"],\\n 'put': data[\\\"putCall\\\"],\\n 'put_bid': data[\\\"bid\\\"],\\n 'put_ask': data[\\\"ask\\\"],\\n 'put_last': data[\\\"last\\\"],\\n 'put_mark': data[\\\"mark\\\"],\\n 'put_bidSize': data[\\\"bidSize\\\"],\\n 'put_askSize': data[\\\"askSize\\\"],\\n 'put_bidAskSize': data[\\\"bidAskSize\\\"],\\n 'put_lastSize': data[\\\"lastSize\\\"],\\n 'put_highPrice': data[\\\"highPrice\\\"],\\n 'put_lowPrice': data[\\\"lowPrice\\\"],\\n 'put_openPrice': data[\\\"openPrice\\\"],\\n 'put_closePrice': data[\\\"closePrice\\\"],\\n 'put_totalVolume': data[\\\"totalVolume\\\"],\\n 'put_tradeDate': data[\\\"tradeDate\\\"],\\n 'put_tradeTimeInLong': data[\\\"tradeTimeInLong\\\"],\\n 'put_quoteTimeInLong': data[\\\"quoteTimeInLong\\\"],\\n 'put_netChange': data[\\\"netChange\\\"],\\n 'put_volatility': data[\\\"volatility\\\"],\\n 'put_delta': data[\\\"delta\\\"],\\n 'put_gamma': data[\\\"gamma\\\"],\\n 'put_theta': data[\\\"theta\\\"],\\n 'put_vega': data[\\\"vega\\\"],\\n 'put_rho': data[\\\"rho\\\"],\\n 'put_openInterest': data[\\\"openInterest\\\"],\\n 'put_timeValue': data[\\\"timeValue\\\"],\\n 'put_theoreticalOptionValue': data[\\\"theoreticalOptionValue\\\"],\\n 'put_theoreticalVolatility': data[\\\"theoreticalVolatility\\\"],\\n 'put_optionDeliverablesList': data[\\\"optionDeliverablesList\\\"],\\n 'put_expirationType': data[\\\"expirationType\\\"],\\n 'put_lastTradingDay': data[\\\"lastTradingDay\\\"],\\n 'put_multiplier': data[\\\"multiplier\\\"],\\n 'put_percentChange': data[\\\"percentChange\\\"],\\n 'put_markChange': data[\\\"markChange\\\"],\\n 'put_markPercentChange': data[\\\"markPercentChange\\\"]},\\n ignore_index=True)\\n\\n self.options_chain = pd.merge(call_options, put_options, how='outer', on=['strikePrice', 'expirationDate', 'daysToExpiration'], suffixes=(\\\"_call\\\", \\\"_put\\\"))\\n self.options_chain['expirationDate'] = pd.to_datetime(self.options_chain['expirationDate'], unit = \\\"ms\\\")\\n\\n self.options_chain[\\\"call_put_volume\\\"] = self.options_chain[\\\"call_totalVolume\\\"] / self.options_chain[\\\"put_totalVolume\\\"]\\n self.options_chain[\\\"call_put_oi\\\"] = self.options_chain[\\\"call_openInterest\\\"] / self.options_chain[\\\"put_openInterest\\\"]\\n self.options_chain[\\\"call_volume_oi\\\"] = self.options_chain[\\\"call_totalVolume\\\"] / self.options_chain[\\\"call_openInterest\\\"]\\n\\n self.options_chain[\\\"put_call_volume\\\"] = self.options_chain[\\\"put_totalVolume\\\"] / self.options_chain[\\\"call_totalVolume\\\"]\\n self.options_chain[\\\"put_call_oi\\\"] = self.options_chain[\\\"put_openInterest\\\"] / self.options_chain[\\\"call_openInterest\\\"]\\n self.options_chain[\\\"put_volume_oi\\\"] = self.options_chain[\\\"put_totalVolume\\\"] / self.options_chain[\\\"put_openInterest\\\"]\\n\\n self.options_chain[\\\"ticker\\\"] = self.ticker\\n\\n self.options_chain = self.options_chain.replace(np.nan, 0)\\n self.options_chain = self.options_chain.replace([np.inf, -np.inf], 999999)\\n\\n return self.options_chain\\n\\n else:\\n return call_options\",\n \"def test_get_offers(self):\\n pass\",\n \"def get_queryset(self):\\n as_of = date.today()\\n\\n result = ExpectedUse.objects.filter(\\n Q(expiration_date__gte=as_of) | Q(expiration_date=None)\\n ).order_by('display_order')\\n result = result.filter(\\n effective_date__lte=as_of\\n ).order_by('display_order')\\n\\n return result\",\n \"def resolve_params(self) -> List[WhereType]:\\n conditions = []\\n\\n # Update start to be within retention\\n expired = False\\n if self.start and self.end:\\n expired, self.start = outside_retention_with_modified_start(\\n self.start, self.end, self.params.organization\\n )\\n\\n if expired:\\n raise QueryOutsideRetentionError(\\n \\\"Invalid date range. Please try a more recent date range.\\\"\\n )\\n\\n if self.start:\\n conditions.append(Condition(self.column(\\\"timestamp\\\"), Op.GTE, self.start))\\n if self.end:\\n conditions.append(Condition(self.column(\\\"timestamp\\\"), Op.LT, self.end))\\n\\n conditions.append(\\n Condition(\\n self.column(\\\"project_id\\\"),\\n Op.IN,\\n self.params.project_ids,\\n )\\n )\\n\\n if len(self.params.environments) > 0:\\n term = event_search.SearchFilter(\\n event_search.SearchKey(\\\"environment\\\"),\\n \\\"=\\\",\\n event_search.SearchValue(self.params.environment_names),\\n )\\n condition = self._environment_filter_converter(term)\\n if condition:\\n conditions.append(condition)\\n\\n if self.requires_organization_condition:\\n if self.params.organization is None:\\n raise InvalidSearchQuery(\\\"Organization is a required parameter\\\")\\n\\n conditions.append(\\n Condition(\\n self.column(self.organization_column),\\n Op.EQ,\\n self.params.organization.id,\\n )\\n )\\n\\n return conditions\",\n \"def append_new_offers(old_offers, new_offers):\\n return [{'offers': new_offers, 'added_at': datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")}, *old_offers]\",\n \"def solve_filter_metrics(self):\\n\\n if 'metrics' in self.filter_request:\\n filter_metrics = self.filter_request['metrics']\\n metrics_request = {}\\n\\n temp = filter_metrics.split(',')\\n for i in temp:\\n metrics_request[i.strip()] = None\\n\\n for i in range(len(self.list_pack)):\\n self.apply_filter_metrics(i, metrics_request.copy())\",\n \"def test_magnitude_filters(self):\\n credentials = Mock(base_url=\\\"\\\")\\n\\n manager = Manager('invoices', credentials)\\n uri, params, method, body, headers, singleobject = manager._filter(**{'Date__gt': datetime.datetime(2007, 12, 6)})\\n\\n self.assertEqual(\\n params,\\n {u'where': u'Date>DateTime(2007,12,6)'}\\n )\\n\\n manager = Manager('invoices', credentials)\\n uri, params, method, body, headers, singleobject = manager._filter(**{'Date__lte': datetime.datetime(2007, 12, 6)})\\n\\n self.assertEqual(\\n params,\\n {u'where': u'Date<=DateTime(2007,12,6)'}\\n )\",\n \"def queryset(self, request, queryset):\\n # Compare the requested value (either '80s' or '90s')\\n # to decide how to filter the queryset.\\n\\n if self.value() == 'passed':\\n return queryset.filter(renewal_date__lt=datetime.datetime.now())\\n if self.value() == 'today':\\n return queryset.filter(renewal_date__gte=datetime.datetime.now(),\\n renewal_date__lte=datetime.datetime.now() + datetime.timedelta(days=1))\\n if self.value() == 'week':\\n return queryset.filter(renewal_date__gte=datetime.datetime.now() + datetime.timedelta(days=1),\\n renewal_date__lte=datetime.datetime.now() + datetime.timedelta(days=7))\\n if self.value() == 'month':\\n return queryset.filter(renewal_date__gte=datetime.datetime.now() + datetime.timedelta(days=7),\\n renewal_date__lte=datetime.datetime.now() + datetime.timedelta(days=31))\",\n \"def __getQuerysetGivenInterval(model, start_date, end_date):\\n cur_model = {\\n 'donor': Donor,\\n 'donation': Donation,\\n 'item': Item\\n }.get(model, Donor.objects.none())\\n\\n # might need following lines when changing back to created_at:\\n # date_format = \\\"%Y-%m-%d\\\"\\n # if start_date is not None:\\n # timezone_unaware_start_date = datetime.strptime(start_date, date_format)\\n # timezone_aware_start_date = pytz.utc.localize(timezone_unaware_start_date)\\n #\\n # if end_date is not None:\\n # timezone_unaware_end_date = datetime.strptime(end_date, date_format)\\n # timezone_aware_end_date = pytz.utc.localize(timezone_unaware_end_date).date()\\n\\n if start_date is not None and end_date is not None:\\n return cur_model.objects.filter(documented_at__range=(start_date, end_date))\\n elif start_date is not None and end_date is None:\\n return cur_model.objects.filter(documented_at__gte=start_date)\\n elif start_date is None and end_date is not None:\\n return cur_model.objects.filter(documented_at__lte=end_date)\\n else:\\n return cur_model.objects.all()\",\n \"def _process_alert_source_filters(query, filters):\\n if filters:\\n if not is_valid_model_filters(models.AlertSource, filters):\\n return\\n query = query.filter_by(**filters)\\n\\n return query\",\n \"def get_queryset(self):\\n \\n queryset = queryset = Row.objects.filter(status_active = 1 )\\n\\n # se obtienen queryset del request\\n dataset_id = self.request.query_params.get('dataset_id', None)\\n name_dataset = self.request.query_params.get('name', None)\\n point = self.request.query_params.get('point', None)\\n \\n # se generan las diferentes combinaciones para que los queryset no sea \\n # obligatorios sino que estos sean opcionales\\n\\n if (dataset_id is not None) and (name_dataset is not None) and (point is not None):\\n print(\\\"entro a point \\\")\\n queryset = queryset.filter( point = point , dataset_id = dataset_id, dataset_id__name = \\\"\\\"+(name_dataset))\\n return queryset\\n\\n elif (dataset_id is not None) and (name_dataset is not None):\\n queryset = queryset.filter(dataset_id = dataset_id, dataset_id__name = \\\"\\\"+(name_dataset))\\n return queryset\\n \\n elif (dataset_id is not None) and (point is not None):\\n queryset = queryset.filter(dataset_id = dataset_id, point = point )\\n return queryset\\n\\n elif (name_dataset is not None) and (point is not None):\\n queryset = queryset.filter(dataset_id__name = \\\"\\\"+(name_dataset) , point = point )\\n return queryset\\n\\n\\n if name_dataset is not None:\\n queryset = queryset.filter(dataset_id__name = \\\"\\\"+(name_dataset) )\\n return queryset\\n\\n elif dataset_id is not None:\\n queryset = queryset.filter(dataset_id = dataset_id)\\n return queryset\\n\\n elif point is not None:\\n queryset = queryset.filter(point = point)\\n return queryset\\n else:\\n return queryset\",\n \"def _boundary_filter(self, south, west, north, east):\\n return Q(latitude__gt=south, longitude__gt=west, \\n latitude__lt=north, longitude__lt=east)\",\n \"def filter_by_query(x, _query=None):\\n if _query:\\n scores = [fuzz.partial_ratio(_query, \\\"{0} {1}\\\".format(x[\\\"requester\\\"][\\\"first_name\\\"], x[\\\"requester\\\"][\\\"last_name\\\"])),\\n fuzz.partial_ratio(_query, x[\\\"requester\\\"][\\\"email\\\"]),\\n fuzz.partial_ratio(_query, x[\\\"requester\\\"][\\\"net_id\\\"]),\\n fuzz.partial_ratio(_query, x[\\\"pay_to\\\"][\\\"name\\\"]),\\n fuzz.partial_ratio(_query, x[\\\"pay_to\\\"][\\\"email\\\"]),\\n fuzz.partial_ratio(_query, x[\\\"pay_to\\\"][\\\"id\\\"] or \\\"\\\"),\\n fuzz.partial_ratio(_query, x[\\\"short_description\\\"]),\\n fuzz.partial_ratio(_query, x[\\\"notes\\\"])]\\n\\n if max(scores) > 60:\\n return True\\n return False\\n return True\",\n \"def get_events(start, end, filters=None):\\n\\n from frappe.desk.calendar import get_event_conditions\\n conditions = get_event_conditions('Booking Request', filters)\\n\\n data = frappe.db.sql(\\\"\\\"\\\"\\n SELECT\\n `tabBooking Request`.name, `tabBooking Request`.eta_date,\\n `tabBooking Request`.etd_date, `tabBooking Request`.status, `tabBooking Request Status`.color\\n FROM\\n `tabBooking Request`\\n LEFT JOIN `tabBooking Request Status` ON `tabBooking Request`.status = `tabBooking Request Status`.name\\n WHERE\\n (`tabBooking Request`.docstatus < 2)\\\"\\\"\\\", as_dict=True)\\n\\n return data\",\n \"def _filter(self, location, component=\\\"Hosting\\\", compute_type=None):\\n filters = [\\n [\\\"TERM_MATCH\\\", \\\"location\\\", location],\\n [\\\"TERM_MATCH\\\", \\\"productFamily\\\", \\\"ML Instance\\\"],\\n [\\\"TERM_MATCH\\\", \\\"currentGeneration\\\", \\\"Yes\\\"],\\n [\\\"TERM_MATCH\\\", \\\"component\\\", component]\\n ]\\n if compute_type:\\n filters.append([\\\"TERM_MATCH\\\", \\\"computeType\\\", compute_type])\\n return [{\\n 'Type': x[0],\\n 'Field': x[1],\\n 'Value': x[2]\\n } for x in filters]\",\n \"def search2(term, location, distance):\\n\\n print location\\n if float(distance) <= 5.0:\\n radius = 0.75\\n elif float(distance) > 5.0 and float(distance) <= 10.0:\\n radius = 1.5\\n elif float(distance) > 10.0 and float(distance) <= 25.0:\\n radius = 4\\n elif float(distance) > 25.0 and float(distance) <= 100.0:\\n radius = 8\\n elif float(distance) > 100.0:\\n radius = 15\\n\\n metradius = int(float(1609) * float(radius))\\n print metradius\\n url_params = {\\n 'category_filter': term.replace(' ', '+'),\\n 'radius_filter': metradius,\\n 'll': location.replace(' ', '+'),\\n 'limit': SEARCH_LIMIT\\n }\\n return request(API_HOST, SEARCH_PATH, url_params=url_params)\",\n \"def step_filter(self, qs):\\n return qs\",\n \"def get_queryset(self):\\n\\t\\treturn EffortInstance.objects.order_by('-date_start')[:15]\",\n \"def queryset(self, request):\\n qs = super(AdRepAdvertiserAdmin, self).queryset(request)\\n qs = AdRepAdvertiser.objects.select_related().filter(id__in=qs\\n ).defer('advertiser__site__envelope',\\n 'advertiser__site__geom',\\n 'advertiser__site__point')\\n return qs\",\n \"def get_queryset(self):\\n\\n if self.request.user.is_staff:\\n queryset = Retreat.objects.all()\\n else:\\n queryset = Retreat.objects.filter(\\n is_active=True,\\n hidden=False\\n )\\n queryset = queryset.filter(hide_from_client_admin_panel=False)\\n\\n queryset = queryset.annotate(\\n max_end_date=Max('retreat_dates__end_time'),\\n min_start_date=Min('retreat_dates__start_time'),\\n )\\n\\n # Filter by display_start_time lower than\\n display_start_time_lte = self.request.query_params.get(\\n 'display_start_time_lte',\\n None,\\n )\\n if display_start_time_lte:\\n queryset = queryset.filter(\\n display_start_time__lte=display_start_time_lte\\n )\\n\\n # Filter by display_start_time greater than\\n display_start_time_gte = self.request.query_params.get(\\n 'display_start_time_gte',\\n None,\\n )\\n if display_start_time_gte:\\n queryset = queryset.filter(\\n display_start_time__gte=display_start_time_gte\\n )\\n return queryset\",\n \"def prepare_amazon_request_report_kwargs(self, seller):\\n account = self.env['iap.account'].search([('service_name', '=', 'amazon_ept')])\\n dbuuid = self.env['ir.config_parameter'].sudo().get_param('database.uuid')\\n instances_obj = self.env['amazon.instance.ept']\\n instances = instances_obj.search([('seller_id', '=', seller.id)])\\n marketplaceids = tuple(map(lambda x: x.market_place_id, instances))\\n\\n return {'merchant_id': seller.merchant_id and str(seller.merchant_id) or False,\\n 'auth_token': seller.auth_token and str(seller.auth_token) or False,\\n 'app_name': 'amazon_ept',\\n 'account_token': account.account_token,\\n 'dbuuid': dbuuid,\\n 'amazon_marketplace_code': seller.country_id.amazon_marketplace_code or\\n seller.country_id.code,\\n 'marketplaceids': marketplaceids,\\n }\",\n \"def test_adding_criteria_to_segments(self):\\n pass\",\n \"def filter_plot(mode, country, continent, start_date, end_date, options):\\n # Default is World mode\\n chart_data = world_daywise_df\\n map_data = countries_daywise_df\\n print(country, continent)\\n if mode == SelectionMode.Continents.value:\\n #Continents mode\\n if not isinstance(continent, list):\\n continent = [continent]\\n\\n chart_data = continents_daywise_df[continents_daywise_df['WHO Region'].isin(continent)]\\n map_data = map_data[map_data['WHO Region'].isin(continent)]\\n elif mode == SelectionMode.Countries.value:\\n # Countries mode\\n if not isinstance(country, list):\\n country = [country]\\n\\n chart_data = countries_daywise_df[countries_daywise_df['Country/Region'].isin(country)]\\n map_data = chart_data\\n\\n chart_data = chart_data.query('Date >= @start_date & Date <= @end_date')\\n map_data = map_data.query('Date >= @start_date & Date <= @end_date')\\n\\n # fix error when groupby geometry or put it in the aggregate column\\n temp = map_data.drop(['geometry', 'country_code', 'Date'], axis=1).groupby(['Country/Region']).agg(metrics).reset_index()\\n map_data = join_country_code_data(temp, country_code_data)\\n\\n if is_perCapita(options):\\n for metric in ['Confirmed', 'Deaths', 'Recovered']:\\n chart_data[metric + '_per_capita'] = chart_data[metric] / chart_data['Population']\\n map_data[metric + '_per_capita'] = map_data[metric] / map_data['Population']\\n \\n if is_perCapita(options):\\n return plot(chart_data, 'Confirmed_per_capita', 'Confirmed Cases Per Capita'), \\\\\\n plot(chart_data, 'Deaths_per_capita', 'Confirmed Deaths Per Capita'), \\\\\\n plot(chart_data, 'Recovered_per_capita', 'Confirmed Recoveries Per Capita'), \\\\\\n generate_map(map_data)\\n\\n return plot(chart_data, 'Confirmed', 'Confirmed Cases'), \\\\\\n plot(chart_data, 'Deaths', 'Confirmed Deaths'), \\\\\\n plot(chart_data, 'Recovered', 'Confirmed Recoveries'), \\\\\\n generate_map(map_data)\",\n \"def get_features_near_me(self,collection,point,radius,earth_radius=3963.2): #km = 6371\\n x,y = point\\n res = self.client['rephie'][collection].find( { 'geometry': { '$geoWithin': { '$centerSphere': [ [x, y ] , radius/earth_radius ] } }} )\\n \\n return self._make_result_list(res)\",\n \"def filter_data(df, coords, vel=False, vel_threshold=0.15, radiant_threshold=5):\\n\\tdf = df[(df.range > 110) & (df.range < 130) \\n\\t\\t& (df.th < 70) # Unphysical, given the range cut.\\n\\t\\t& (df.fl == 0)] # Bad interferometry if fl=1\\n\\n\\t# Velocity cut\\n\\tif vel:\\n\\t\\tdf = df[(df.new_ptn > vel*(1-vel_threshold)) \\n\\t\\t& (df.new_ptn < vel*(1+vel_threshold))]\\n\\n\\t# Identify the shower radiant\\n\\tif isinstance(coords, str):\\n\\t\\twavelet = read_wavelet(coords)\\n\\t\\tdf = df.apply(get_wavelet_radiant, axis=1, args=(wavelet,))\\n\\telse:\\n\\t\\tdf['radiant_ll0'] = coords[0]\\n\\t\\tdf['radiant_beta'] = coords[1]\\n\\n\\tdf['separation'] = df.apply(check_radiant, axis=1)\\n\\tdf.drop(['radiant_ll0', 'radiant_beta'], axis=1, inplace=True)\\n\\tdf_shower = df[df['separation'] <= radiant_threshold]\\n\\treturn df_shower\",\n \"def person_search_qs(request):\\n query = request.GET\\n qs = Person.objects.filter(expiry_date__gt=timezone.now())\\n\\n # base registration and application querysets\\n registrations_qs = Register.objects.all()\\n applications_qs = RegistriesApplication.objects.all()\\n\\n person_filters = Q()\\n reg_filters = Q()\\n appl_filters = Q()\\n\\n\\n # Search for cities (split list and return all matches)\\n # search comes in as a comma-separated querystring param e.g: ?city=Atlin,Lake Windermere,Duncan\\n cities = query.get('city', None)\\n if cities:\\n cities = cities.split(',')\\n person_filters = person_filters & Q(registrations__organization__city__in=cities)\\n reg_filters = reg_filters & Q(organization__city__in=cities)\\n \\n # regional areas\\n region_guids = query.get('region', None)\\n if region_guids:\\n region_guids = region_guids.split(',')\\n regional_areas = RegionalArea.objects.filter(regional_area_guid__in=region_guids)\\n person_filters &= Q(registrations__organization__regional_areas__in=regional_areas)\\n reg_filters &= Q(organization__regional_areas__in=regional_areas)\\n\\n #bbox\\n sw_long = query.get('sw_long')\\n sw_lat = query.get('sw_lat')\\n ne_long = query.get('ne_long')\\n ne_lat = query.get('ne_lat')\\n if sw_long and sw_lat and ne_long and ne_lat:\\n try:\\n bbox = Polygon.from_bbox((sw_long, sw_lat, ne_long, ne_lat))\\n bbox.srid = 4326\\n person_filters = person_filters & Q(registrations__organization__geom__bboverlaps=bbox)\\n reg_filters = reg_filters & Q(organization__geom__bboverlaps=bbox)\\n except (ValueError, GEOSException):\\n pass\\n\\n #Subactivities param comes as a csv list\\n subactivities = query.get('subactivities')\\n if subactivities is not None: \\n subactivities = subactivities.split(\\\",\\\")\\n person_filters = person_filters & \\\\\\n Q(registrations__applications__subactivity__registries_subactivity_code__in=subactivities)\\n reg_filters = reg_filters & \\\\\\n Q(applications__subactivity__registries_subactivity_code__in=subactivities)\\n appl_filters = appl_filters & \\\\\\n Q(subactivity__registries_subactivity_code__in=subactivities)\\n\\n activity = query.get('activity', None)\\n status = query.get('status', None)\\n user_is_staff = request.user.groups.filter(name=REGISTRIES_VIEWER_ROLE).exists()\\n\\n if activity:\\n if (status == 'P' or not status) and user_is_staff:\\n # We only allow staff to filter on status\\n # For pending, or all, we also return search where there is no registration.\\n person_filters = person_filters & \\\\\\n (\\n Q(registrations__registries_activity__registries_activity_code=activity) |\\n Q(registrations__isnull=True)\\n )\\n reg_filters = reg_filters & \\\\\\n Q(registries_activity__registries_activity_code=activity)\\n else:\\n # For all other searches, we strictly filter on activity.\\n person_filters = person_filters & \\\\\\n Q(registrations__registries_activity__registries_activity_code=activity)\\n reg_filters = reg_filters & \\\\\\n Q(registries_activity__registries_activity_code=activity)\\n\\n if user_is_staff:\\n # User is logged in\\n if status:\\n if status == 'Removed':\\n # Things are a bit more complicated if we're looking for removed, as the current\\n # status doesn't come in to play.\\n person_filters = person_filters & \\\\\\n Q(registrations__applications__removal_date__isnull=False)\\n reg_filters = reg_filters & \\\\\\n Q(applications__removal_date__isnull=False)\\n appl_filters = appl_filters & \\\\\\n Q(removal_date__isnull=False)\\n else:\\n if status == 'P':\\n # If the status is pending, we also pull in any people without registrations\\n # or applications.\\n person_filters = person_filters & \\\\\\n (\\n Q(registrations__applications__current_status__code=status) |\\n Q(registrations__isnull=True) |\\n Q(registrations__applications__isnull=True) \\n ) & \\\\\\n Q(registrations__applications__removal_date__isnull=True)\\n reg_filters = reg_filters & \\\\\\n (\\n Q(applications__current_status__code=status) | \\n Q(applications__isnull=True) \\n ) & \\\\\\n Q(applications__removal_date__isnull=True) \\n appl_filters = appl_filters & \\\\\\n (\\n Q(current_status__code=status) \\n #Q(isnull=True) \\n ) & \\\\\\n Q(removal_date__isnull=True) \\n else:\\n person_filters = person_filters & \\\\\\n (\\n Q(registrations__applications__current_status__code=status) &\\n Q(registrations__applications__removal_date__isnull=True)\\n )\\n reg_filters = reg_filters & \\\\\\n (\\n Q(applications__current_status__code=status) &\\n Q(applications__removal_date__isnull=True)\\n )\\n appl_filters = appl_filters & \\\\\\n (\\n Q(current_status__code=status) &\\n Q(removal_date__isnull=True)\\n )\\n else:\\n # User is not logged in\\n # Only show active drillers to non-admin users and public\\n person_filters = person_filters & \\\\\\n (\\n Q(registrations__applications__current_status__code='A') &\\n Q(registrations__applications__removal_date__isnull=True)\\n )\\n\\n reg_filters = reg_filters & \\\\\\n (\\n Q(applications__current_status__code='A') &\\n Q(applications__removal_date__isnull=True)\\n )\\n appl_filters= appl_filters & \\\\\\n (\\n Q(current_status='A') & \\n Q(removal_date__isnull=True)\\n )\\n\\n #apply all the \\\"main\\\" and \\\"registration\\\" filters that were chosen above\\n qs = qs.filter(person_filters)\\n registrations_qs = registrations_qs.filter(reg_filters)\\n applications_qs = applications_qs.filter(appl_filters)\\n\\n\\n # generate applications queryset\\n applications_qs = applications_qs \\\\\\n .select_related(\\n 'current_status',\\n 'primary_certificate',\\n 'primary_certificate__cert_auth',\\n 'subactivity',\\n ) \\\\\\n .prefetch_related(\\n 'subactivity__qualification_set',\\n 'subactivity__qualification_set__well_class'\\n ).distinct() \\n\\n # generate registrations queryset, inserting filtered applications queryset defined above\\n registrations_qs = registrations_qs \\\\\\n .select_related(\\n 'registries_activity',\\n 'organization',\\n 'organization__province_state',\\n ) \\\\\\n .prefetch_related(\\n Prefetch('applications', queryset=applications_qs)\\n ).distinct() \\n\\n # insert filtered registrations set\\n qs = qs \\\\\\n .prefetch_related(\\n Prefetch('registrations', queryset=registrations_qs)\\n )\\n\\n return qs.distinct()\",\n \"def calculate_event_price_and_parameters(self, event_id):\\n try:\\n price = 0\\n proffesional_staff = 0\\n middle_staff = 0\\n new_staff = 0\\n\\n req_id, _, client_id, title, location, date_starts, date_ends, guests, event_type_id, event_class_id, _ = self.db_handler.get_event_request_extended_info_by_id(event_id)\\n _, event_class_name, guests_per_waiter = self.db_handler.get_event_class_by_id(event_class_id)\\n\\n distance_in_km = self.get_geopy_distance(location)\\n price = distance_in_km * float(self.get_config_value('PRICE_OF_KM'))\\n num_of_staff = math.ceil(guests / guests_per_waiter)\\n\\n if event_class_name == 'Найвищий': #85% of pro\\n new_staff = 0\\n proffesional_staff = math.ceil(num_of_staff * 0.85)\\n middle_staff = num_of_staff - proffesional_staff\\n elif event_class_name == 'Високий': #75% of pro\\n new_staff = 0\\n proffesional_staff = math.ceil(num_of_staff * 0.75)\\n middle_staff = num_of_staff - proffesional_staff\\n elif event_class_name == 'Середній':\\n new_staff = round(num_of_staff * 0.2)\\n middle_staff = num_of_staff - new_staff\\n elif event_class_name == 'Початковий':\\n middle_staff = math.ceil(num_of_staff * 0.3)\\n new_staff = round(num_of_staff - middle_staff)\\n\\n hours_of_shift = (date_ends - date_starts).seconds / 3600\\n\\n price += proffesional_staff * float(self.get_config_value('PRO_RATE')) * hours_of_shift\\n price += middle_staff * float(self.get_config_value('MID_RATE')) * hours_of_shift\\n price += new_staff * float(self.get_config_value('NEW_RATE')) * hours_of_shift\\n\\n price += price * 0.4\\n\\n return (price,proffesional_staff,middle_staff,new_staff)\\n except Exception as err:\\n method_name = sys._getframe().f_code.co_name\\n\\n self.logger.write_to_log('exception', 'model')\\n self.logger.write_to_err_log(f'exception in method {method_name} - {err}', 'model')\",\n \"def get(self, request):\\n TODOs = Todotbl.objects.all() if request.user.role == User.ADMIN else Todotbl.objects.filter(user=request.user)\\n for filterData in re.split(Filter.separator, request.data[Filter.column]):\\n filterDataMake = FilterData()\\n # set column to search\\n if Filter.column_priority in filterData:\\n filterDataMake.columnName = Filter.column_priority\\n elif Filter.column_status in filterData:\\n filterDataMake.columnName = Filter.column_status\\n\\n # what search (order by or filtering)\\n if Filter.asc in filterData: # order by asc\\n filterDataMake.val = Filter.asc\\n TODOs = Todotbl.objects.filter(id__in=TODOs).order_by(filterDataMake.columnName).distinct()\\n elif Filter.desc in filterData: # order by desc\\n filterDataMake.val = Filter.desc\\n TODOs = Todotbl.objects.filter(id__in=TODOs).order_by(filterDataMake.columnName).reverse().distinct()\\n else:\\n if Filter.more in filterData: # if more\\n filterDataMake.isMore = True\\n elif Filter.less in filterData: # if less\\n filterDataMake.isLess = True\\n\\n if Filter.equal in filterData: # if equal\\n filterDataMake.isEqual = True\\n if filterDataMake.isMore: # if more equal\\n if Filter.column_priority == filterDataMake.columnName: # if more equal in column priority\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n priority__gte=validate_priority(filterData)).distinct()\\n elif Filter.column_status == filterDataMake.columnName: # if more equal in column status\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n status__gte=validate_word_status(filterData, '>=')) \\\\\\n .distinct()\\n elif filterDataMake.isLess: # if less equal\\n if Filter.column_priority == filterDataMake.columnName: # if less equal in column priority\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n priority__lte=validate_priority(filterData)).distinct()\\n elif Filter.column_status == filterDataMake.columnName: # if less equal in column status\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n status__lte=validate_word_status(filterData,\\n '<=')).distinct()\\n else: # if equal\\n if Filter.column_priority == filterDataMake.columnName: # if equal in column priority\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n priority=validate_priority(filterData)).distinct()\\n elif Filter.column_status == filterDataMake.columnName: # if equal in column status\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n status=validate_word_status(filterData, '=')).distinct()\\n\\n else: # if not equal, only more or less\\n if filterDataMake.isMore: # if more\\n if Filter.column_priority == filterDataMake.columnName: # if more in column priority\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n priority__gt=validate_priority(filterData)).distinct()\\n elif Filter.column_status == filterDataMake.columnName: # if more in column status\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n status__gt=validate_word_status(filterData, '>')).distinct()\\n else: # if less\\n if Filter.column_priority == filterDataMake.columnName: # if less in column priority\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n priority__lt=validate_priority(filterData)).distinct()\\n elif Filter.column_status == filterDataMake.columnName: # if less in column status\\n TODOs = Todotbl.objects.filter(id__in=TODOs,\\n status__lt=validate_word_status(filterData, '<')).distinct()\\n return Response((model_to_dict(TODO) for TODO in TODOs), status=status.HTTP_200_OK)\",\n \"def _filter_by_date(from_date, until_date):\\n qlist = []\\n\\n if from_date:\\n qlist.append(Q(oai_date_stamp__gte=from_date))\\n\\n if until_date:\\n qlist.append(Q(oai_date_stamp__lte=until_date))\\n\\n return qlist\",\n \"def df_effective_sale(start=None, end=None, f=None, all=False):\\n df = DataFrame(columns=['efectivas'])\\n \\n def is_effective(row):\\n if row[1].startswith('gestion 3') and row[0] >= 14:\\n return True\\n elif row[1].startswith('gestion') and row[0] >= 7:\\n return True\\n elif ~row[1].startswith('gestion') and row[0] > 0:\\n return True\\n else:\\n return False\\n\\n hits = search_sale_values(start, end, f)\\n\\n obj = {}\\n\\n for hit in hits:\\n if hit.type in SALE_VALUES:\\n task_id = hit.task_id\\n amount = SALE_VALUES.get(hit.type, 0)\\n obj[task_id] = obj.get(task_id, 0) + amount\\n\\n if obj == {}:\\n df.loc['total'] = df.sum()\\n return df.astype('int64')\\n\\n df_sv = DataFrame.from_dict(obj, orient='index')\\n df_sv.index.name = 'task_id'\\n\\n hits = search_sale_tasks(start, end, f)\\n\\n obj = { hit.task_id: hit.remarks for hit in hits }\\n\\n if obj == {}:\\n df.loc['total'] = df.sum()\\n return df.astype('int64')\\n\\n df_g = DataFrame.from_dict(obj, orient='index')\\n df_g.index.name = 'task_id'\\n\\n df = df_sv.merge(df_g, on='task_id', how='inner')\\n df['effective'] = df.apply(is_effective, axis=1)\\n df = df.drop('0_x', axis=1).groupby('0_y').sum()\\n\\n obj = {}\\n\\n for remark in df.index.tolist():\\n if (\\n remark.startswith('gestion') or\\n remark.startswith('gestion 2') or\\n remark.startswith('gestion 3')\\n ):\\n tipo = 'gestión'\\n elif remark.startswith('ticket'):\\n tipo = 'ticket'\\n elif remark.startswith('verificacion'):\\n tipo = 'verificación'\\n elif remark.startswith('tendero venta'):\\n tipo = 'tendero Venta'\\n elif remark.startswith('tendero sync'):\\n tipo = 'tendero Sync'\\n elif remark.startswith('kingo basico'):\\n tipo = 'swap k7 o venta >= 1 semana'\\n elif remark.startswith('kingo tv'):\\n tipo = 'swap a kingo tv'\\n elif (\\n remark.startswith('tecnica') or\\n remark.startswith('promocion precio') or\\n remark.startswith('corregir') or\\n remark.startswith('cliente activo') or\\n remark.startswith('asignacion especial tecnica')\\n ):\\n tipo = 'técnica'\\n elif (\\n remark.startswith('preventa kingo tv') or\\n remark.startswith('preventa: k15 tv') or\\n remark.startswith('preventa: kingo tv')\\n ):\\n tipo = 'Preventa Kingo TV'\\n elif remark.startswith('preventa kingo hogar'):\\n tipo = 'Preventa Kingo Hogar'\\n else:\\n tipo = 'sin tipo'\\n obj[tipo] = obj.get(tipo, 0) + df.at[remark, 'effective']\\n\\n df = DataFrame.from_dict(obj, orient='index', columns=['efectivas'])\\n df = df.astype('int64').sort_index()\\n\\n if not all and 'sin tipo' in df.index:\\n df = df.drop('sin tipo')\\n\\n df.loc['total'] = df.sum()\\n df.index.name = 'tipo de tarea'\\n\\n return df\",\n \"def _get_endpoint_list(name, filter_by, limit, offset, quiet, all_items):\\n\\n get_endpoint_list(name, filter_by, limit, offset, quiet, all_items)\",\n \"def execute_search(locations, distance, query):\\n full_business_list = []\\n for engine in [google, yelp]:\\n businesses = []\\n for lat, lng in locations:\\n businesses.extend(engine.search(lat, lng, distance, query))\\n # Remove duplicates from API call overlap\\n names = set()\\n filtered_list = []\\n print(time.strftime(\\\"%Y/%m/%d at %H:%M:%S \\\") + engine.__name__ + \\\" \\\" + str(len(businesses)))\\n for business in businesses:\\n if business:\\n filtered_list.append(business)\\n names.add(business.name)\\n businesses = filtered_list\\n # Calculate low threshold and average ratings\\n try:\\n low_threshold = min(\\n business.rating_count for business in businesses)\\n except:\\n # go to next item\\n continue\\n average_rating = sum(\\n business.rating for business in businesses) / len(businesses)\\n # Convert to 10 point scale\\n scale_multiplier = 2\\n # Add bayesian estimates to business objects\\n for business in businesses:\\n business.bayesian = bayesian(business.rating * scale_multiplier,\\n business.rating_count,\\n low_threshold,\\n average_rating * scale_multiplier)\\n\\n # Add this search engine's list to full business list\\n full_business_list.extend(businesses)\\n\\n return full_business_list\",\n \"def get_filtered(self, collection, xmlFormat):\\n\\t\\tstart = \\\"2012-05-01T00:00:00Z\\\"\\n\\t\\tend = \\\"2012-05-20T00:00:00Z\\\"\\n\\t\\tquery = '/text//annotationRecord/service/date/@modified:[%s TO %s]' % (start, end)\\n\\t\\t\\n\\t\\treturn {\\n\\t\\t\\t'q' : query,\\n\\t\\t\\t\\\"verb\\\": \\\"Search\\\",\\n\\t\\t\\t\\\"xmlFormat\\\": xmlFormat,\\n\\t\\t\\t\\\"ky\\\": collection,\\n\\t\\t\\t'sortDescending' : '/text//annotationRecord/service/date/@modified'\\n\\t\\t\\t}\",\n \"def _parse_optimizer_params(self, params):\\n i = 0\\n for filt in self.filters:\\n if filt.optimize_fc:\\n filt.fc = 10 ** params[i]\\n i += 1\\n if filt.optimize_q:\\n filt.q = params[i]\\n i += 1\\n if filt.optimize_gain:\\n filt.gain = params[i]\\n i += 1\",\n \"def filter_criteria_met(current_gre, current_gpa, current_toefl):\\r\\n\\r\\n if int(current_gre) < global_constants['MINIMUM_GRE']:\\r\\n return False\\r\\n if float(current_gpa) < global_constants['MINIMUM_GPA']:\\r\\n return False\\r\\n if int(current_toefl) < global_constants['MINIMUM_TOEFL']:\\r\\n return False\\r\\n return True\",\n \"def build_query_structure(self):\\n query_list = list()\\n filter_list = list()\\n for key, val in self.q_dict.items():\\n if key in self.es_query_keys:\\n query_list.append(\\n {\\\"match\\\": {\\\".\\\".join(key.split(\\\"_\\\")): val[0]}})\\n elif key in self.es_date_keys:\\n filter_list.append(\\n {\\\"range\\\": {\\\".\\\".join(key.split(\\\"_\\\")): val}})\\n elif \\\":\\\" in val[0]:\\n #for handling queries like dd_dct=gte:1\\n range_val = val[0].split(\\\":\\\")\\n filter_list.append({\\\"range\\\": {\\\".\\\".join(key.split(\\\"_\\\")): {\\n range_val[0]: int(range_val[1])}}})\\n else:\\n filter_list.append(\\n {\\\"terms\\\": {\\\".\\\".join(key.split(\\\"_\\\")): val}})\\n return query_list, filter_list\",\n \"def default_filters(self, query) -> object:\\n user = self.request.user\\n model = self.model\\n custom_filter = self.request.params.get('_custom_filter')\\n if 'g:professionals' in user.groups and custom_filter == 'pool':\\n # disable security for this custom filter\\n self.enable_security = False\\n professional = Professional.get(user.id)\\n pool_ids = [item.id for item in professional.pools]\\n query = query.filter(\\n model.pool_id.in_(pool_ids),\\n model.state == 'published'\\n )\\n elif custom_filter == 'late_first_submission':\\n config_delta = timedelta(seconds=int(LATE_SUBMISSION_SECONDS))\\n date_limit = datetime_utcnow() - config_delta\\n query = query.filter(\\n model.scheduled_datetime <= date_limit,\\n model.state == 'awaiting_assets',\\n model.last_approval_date.is_(None)\\n )\\n elif custom_filter == 'late_re_submission':\\n config_delta = timedelta(seconds=int(LATE_SUBMISSION_SECONDS))\\n date_limit = datetime_utcnow() - config_delta\\n query = query.filter(\\n model.last_approval_date <= date_limit,\\n model.state == 'awaiting_assets',\\n model.submission_path.isnot(None),\\n )\\n return query\",\n \"def get_queryset(self):\\n\\n circle = self.circle\\n\\n if self.action not in ['finish', 'qualify']:\\n offset = timezone.now() + timedelta(minutes=10)\\n\\n queryset = circle.ride_set.filter(\\n available_seats__gte=1,\\n departure_date__gte=offset\\n )\\n else:\\n queryset = circle.ride_set.all()\\n\\n return queryset\",\n \"def _get_applicable_offers(self, current_protocol, path):\\n\\n edges = []\\n\\n for from_protocol_name, offers in self._adaptation_offers.items():\\n from_protocol = offers[0].from_protocol\\n mro_distance = self.mro_distance_to_protocol(\\n current_protocol, from_protocol\\n )\\n\\n if mro_distance is not None:\\n\\n for offer in offers:\\n # Avoid cycles by checking that we did not consider this\\n # offer in this path.\\n if offer not in path:\\n edges.append((mro_distance, offer))\\n\\n return edges\",\n \"def filter_by_query_params(self, request):\\n items = self\\n project = request.GET.get('project', None)\\n customer = request.GET.get('customer', None)\\n company = request.GET.get('company', None)\\n engineer = request.GET.get('engineer', None)\\n q = request.GET.get('q', None)\\n sort_by = request.GET.get('sort_by', None)\\n str = request.GET.get('str', None)\\n\\n if project:\\n items = items.filter(project=project).distinct()\\n if engineer:\\n items = items.filter(lead__sales_engineer=engineer).distinct()\\n if customer:\\n items = items.filter(lead__customer=customer).distinct()\\n if company:\\n items = items.filter(company=company).distinct()\\n # sort\\n if q == 'asc' and sort_by:\\n items = items.order_by(sort_by).distinct()\\n\\n if q == 'des' and sort_by:\\n items = items.order_by('-' + sort_by).distinct()\\n\\n if str:\\n # str = str.strip().lower()\\n items = items.filter(Q(reference_no__icontains=str) |\\n Q(erp_reference__icontains=str)).distinct()\\n return items\",\n \"def get_filters():\\n print('Hello! Let\\\\'s explore some US bikeshare data!')\",\n \"def get_active_features(summary_df, slots_offered): # prev -> getActiveFeatures\\n disc_cols = [col+'_Discount' for col in slots_offered]\\n eco_cols = [col+'_Eco' for col in slots_offered]\\n gr_cols = [col+'_Eco' for col in slots_offered]\\n features = summary_df.loc[:, disc_cols+eco_cols+gr_cols]\\n features = features.loc[:, features.sum(axis=0) > 0]\\n for i in reversed(['NO_PURCHASE']+slots_offered):\\n features.insert(0, i+'_Asc', value=1)\\n return features, disc_cols, eco_cols, gr_cols\",\n \"def nearby(point, radius, unit):\\n qs = MyModel.objects.all()\\n qs = qs.filter(point__distance_lte=(point, D(**{unit: radius})))\\n qs = qs.distance(point) # at this point, the type of queryset is GeoQuerySet\\n qs = qs.order_by('distance')\\n return qs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5478844","0.54343915","0.5411153","0.52321213","0.5225025","0.51286703","0.51178557","0.50775","0.5036253","0.5035772","0.503197","0.50226885","0.5009665","0.5009194","0.49829316","0.49653837","0.49478367","0.49094522","0.49093115","0.4901606","0.48850656","0.48770344","0.48765272","0.48761284","0.48693496","0.48607928","0.48489863","0.48135868","0.48007196","0.4793626","0.4786426","0.47611365","0.47608805","0.47353435","0.47347993","0.473458","0.47294813","0.47241154","0.4710049","0.47075814","0.47003472","0.46892673","0.46824902","0.46713626","0.4663995","0.46617356","0.46437192","0.46414775","0.4640305","0.46361166","0.46349344","0.46333092","0.4629328","0.46276784","0.4625148","0.46250248","0.46221012","0.46208417","0.46207523","0.46175689","0.4614984","0.4606846","0.46040353","0.46034172","0.460126","0.4598591","0.45964676","0.4594894","0.4593833","0.45860445","0.45825934","0.45730457","0.45725435","0.45575315","0.45558557","0.4552539","0.45461994","0.4540635","0.45399708","0.45390353","0.45321393","0.45312756","0.4530158","0.45294333","0.45287433","0.45262712","0.4519295","0.45152164","0.45064855","0.45017457","0.44994238","0.44984114","0.44968018","0.44952652","0.4494069","0.44939005","0.44924545","0.44879162","0.44813472","0.44799823","0.44795513"],"string":"[\n \"0.5478844\",\n \"0.54343915\",\n \"0.5411153\",\n \"0.52321213\",\n \"0.5225025\",\n \"0.51286703\",\n \"0.51178557\",\n \"0.50775\",\n \"0.5036253\",\n \"0.5035772\",\n \"0.503197\",\n \"0.50226885\",\n \"0.5009665\",\n \"0.5009194\",\n \"0.49829316\",\n \"0.49653837\",\n \"0.49478367\",\n \"0.49094522\",\n \"0.49093115\",\n \"0.4901606\",\n \"0.48850656\",\n \"0.48770344\",\n \"0.48765272\",\n \"0.48761284\",\n \"0.48693496\",\n \"0.48607928\",\n \"0.48489863\",\n \"0.48135868\",\n \"0.48007196\",\n \"0.4793626\",\n \"0.4786426\",\n \"0.47611365\",\n \"0.47608805\",\n \"0.47353435\",\n \"0.47347993\",\n \"0.473458\",\n \"0.47294813\",\n \"0.47241154\",\n \"0.4710049\",\n \"0.47075814\",\n \"0.47003472\",\n \"0.46892673\",\n \"0.46824902\",\n \"0.46713626\",\n \"0.4663995\",\n \"0.46617356\",\n \"0.46437192\",\n \"0.46414775\",\n \"0.4640305\",\n \"0.46361166\",\n \"0.46349344\",\n \"0.46333092\",\n \"0.4629328\",\n \"0.46276784\",\n \"0.4625148\",\n \"0.46250248\",\n \"0.46221012\",\n \"0.46208417\",\n \"0.46207523\",\n \"0.46175689\",\n \"0.4614984\",\n \"0.4606846\",\n \"0.46040353\",\n \"0.46034172\",\n \"0.460126\",\n \"0.4598591\",\n \"0.45964676\",\n \"0.4594894\",\n \"0.4593833\",\n \"0.45860445\",\n \"0.45825934\",\n \"0.45730457\",\n \"0.45725435\",\n \"0.45575315\",\n \"0.45558557\",\n \"0.4552539\",\n \"0.45461994\",\n \"0.4540635\",\n \"0.45399708\",\n \"0.45390353\",\n \"0.45321393\",\n \"0.45312756\",\n \"0.4530158\",\n \"0.45294333\",\n \"0.45287433\",\n \"0.45262712\",\n \"0.4519295\",\n \"0.45152164\",\n \"0.45064855\",\n \"0.45017457\",\n \"0.44994238\",\n \"0.44984114\",\n \"0.44968018\",\n \"0.44952652\",\n \"0.4494069\",\n \"0.44939005\",\n \"0.44924545\",\n \"0.44879162\",\n \"0.44813472\",\n \"0.44799823\",\n \"0.44795513\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14867,"cells":{"query":{"kind":"string","value":"Convert unit with default UnitRegistry (i.e, application_registry)"},"document":{"kind":"string","value":"def test_convert_unit_with_pint(test_df, current, to):\n df = get_units_test_df(test_df)\n\n # replace EJ/yr by EJ to test pint with single unit\n if current == \"EJ\":\n df.rename(unit={\"EJ/yr\": \"EJ\"}, inplace=True)\n\n exp = pd.Series([1.0, 6.0, 138.88, 833.33, 555.55, 1944.44], name=\"value\")\n assert_converted_units(df, current, to, exp)"},"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 _convert_unit(self, unit):\n if unit in self.units:\n return self.units[unit]\n elif unit in unit_map:\n return unit_map[unit]\n else:\n raise SBMLError('Unit not recognized: ' + str(unit))","def test_convert_unit_with_custom_registry(test_df):\n df = get_units_test_df(test_df).rename(unit={\"EJ/yr\": \"foo\"})\n\n # check that conversion fails with application registry\n with pytest.raises(pint.UndefinedUnitError):\n df.convert_unit(\"foo\", \"baz\")\n\n # define a custom unit registry\n ureg = pint.UnitRegistry()\n ureg.define(\"baz = [custom]\")\n ureg.define(\"foo = 3 * baz\")\n\n exp = pd.Series([1.0, 6.0, 1.5, 9, 6, 21], name=\"value\")\n assert_converted_units(df, \"foo\", \"baz\", exp, registry=ureg)","def reload_unit_registry():\n\n import time\n t_start = time.time()\n\n global _unit_registry\n\n _unit_registry = None\n\n reg = pint.UnitRegistry()\n\n # Define some \"standard\" additional units\n reg.define('piece = 1')\n reg.define('each = 1 = ea')\n reg.define('dozen = 12 = dz')\n reg.define('hundred = 100')\n reg.define('thousand = 1000')\n\n # Allow for custom units to be defined in the database\n try:\n from common.models import CustomUnit\n\n for cu in CustomUnit.objects.all():\n try:\n reg.define(cu.fmt_string())\n except Exception as e:\n logger.error(f'Failed to load custom unit: {cu.fmt_string()} - {e}')\n\n # Once custom units are loaded, save registry\n _unit_registry = reg\n\n except Exception:\n # Database is not ready, or CustomUnit model is not available\n pass\n\n dt = time.time() - t_start\n logger.debug(f'Loaded unit registry in {dt:.3f}s')\n\n return reg","def get_unit_registry():\n\n global _unit_registry\n\n # Cache the unit registry for speedier access\n if _unit_registry is None:\n return reload_unit_registry()\n else:\n return _unit_registry","def unit_registry_to_human_readable(unit_registry):\n if unit_registry is None:\n return None\n new_registry = {}\n integer_one = 1\n for k in SI_base_registry:\n if unit_registry[k] is integer_one:\n new_registry[k] = 1, 1\n else:\n dim_list = list(unit_registry[k].dimensionality)\n if len(dim_list) != 1:\n raise TypeError(\"Compound units not allowed: {}\".format(dim_list))\n u_symbol = dim_list[0].u_symbol\n new_registry[k] = float(unit_registry[k]), u_symbol\n return new_registry","def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\n return process_unit_input(value, units, convert=True, registry=registry).v","def load_unit(self, unit_id):","def assign_unit(self):\n self.units = {}\n for unit in RADIAL_UNITS:\n if unit.REPR == \"2th_deg\":\n self.units[unit] = self.tth_deg\n elif unit.REPR == \"2th_rad\":\n self.units[unit] = self.tth_rad\n elif unit.REPR == \"q_nm^-1\":\n self.units[unit] = self.q_nm\n elif unit.REPR == \"q_A^-1\":\n self.units[unit] = self.q_A\n elif unit.REPR == \"r_mm\":\n self.units[unit] = self.r_mm\n else:\n logger.warning(\"Unit unknown to GUI %s\" % unit)","def get_unit_system(system: SystemLike) -> unyt.UnitSystem:\n if isinstance(system, unyt.UnitSystem):\n return system\n\n try:\n return unyt.unit_systems.unit_system_registry[str(system)]\n except KeyError as exc:\n raise UnitSystemNotFoundError(system) from exc","def SBMLUnitsConverter_init():\n return _libsbml.SBMLUnitsConverter_init()","def get_unit_system(key: str) -> UnitSystem:\n if key == _CONF_UNIT_SYSTEM_US_CUSTOMARY:\n return US_CUSTOMARY_SYSTEM\n if key == _CONF_UNIT_SYSTEM_METRIC:\n return METRIC_SYSTEM\n raise ValueError(f\"`{key}` is not a valid unit system key\")","def convert_units(self, units):\n self.unit_array = self.unit_array.to(units)","def get_converted_unit(\n self,\n device_class: SensorDeviceClass | str | None,\n original_unit: str | None,\n ) -> str | None:\n return self._conversions.get((device_class, original_unit))","def _deprecated_unit_system(value: str) -> str:\n\n if value == _CONF_UNIT_SYSTEM_IMPERIAL:\n # need to add warning in 2023.1\n return _CONF_UNIT_SYSTEM_US_CUSTOMARY\n return value","def unit_to_dict(self, unused_unit):\n raise Exception('Not implemented')","def to_unit(self, unit):\n unit = _find_unit(unit)\n self.value = _convert_value(self.value, self.unit, unit)\n self.unit = unit","def units_to_fits(unit):\n if unit is None:\n unit = Unit('')\n return unit.to_string(\"fits\").upper()","def convertUnit(*args, fromUnit: AnyStr=\"\", toUnit: AnyStr=\"\", **kwargs)->float:\n pass","def _get_units_object(self, units):\n if isinstance(units, cellml_units):\n # We're done\n pass\n else:\n units = amara_parse_cellml(unicode(units))\n assert isinstance(units, cellml_units)\n return units","def convert(x, unit1, unit2):\r\n return conversions[unit1][unit2](x)","def init():\n return _libsbml.SBMLUnitsConverter_init()","def save_unit(self, unit_name):\n\t\tif unit_name:\n\t\t\tunit, created = Unit.objects.get_or_create(name = unit_name)\n\t\t\treturn unit\n\t\telse:\n\t\t\treturn None","def useUnits():","def fits_to_units(unit_str):\n unit_lookup = {\n 'meters': 'm',\n 'meter': 'm',\n 'degrees': 'deg',\n 'degree': 'deg',\n 'hz': 'Hz',\n 'hertz': 'Hz',\n 'second': 's',\n 'sec': 's',\n 'secs': 's',\n 'days': 'd',\n 'day': 'd',\n 'steradians': 'sr',\n 'steradian': 'sr',\n 'radians': 'rad',\n 'radian': 'rad',\n 'jy': 'Jy',\n 'au': 'AU',\n }\n\n try:\n new_units = \"\"\n\n if unit_str is None:\n unit_str = ''\n unit_str = unit_str.lower()\n unit_list = unit_str.split(\"/\")\n\n for uu in unit_list:\n if uu.endswith(\"s\") and len(uu) > 1:\n uu = uu[:-1]\n corrected_unit = unit_lookup.get(uu, uu)\n new_units += corrected_unit\n new_units += \" / \"\n new_units = new_units[:-3]\n unit = Unit(new_units)\n return unit\n\n except ValueError:\n warnings.warn(\"Unknown unit: %s\" % new_units, UnitWarning)\n return UnrecognizedUnit(unit_str)","def _conversion_factor_internal(unit: str):\n return globals()[unit]","def to_base_unit(val: float, unit: str = \"\") -> float:\n unit_scalar = UNITS.get(unit, None)\n if not unit_scalar:\n raise UnknownUnitError(f\"Unit '{unit}' is not supported\")\n\n return val * unit_scalar","def _replace_units(original_units, values_by_name):\n q = 1\n for arg_name, exponent in original_units.items():\n q = q * values_by_name[arg_name] ** exponent\n\n return getattr(q, \"_units\", UnitsContainer({}))","def set_current_units(units=None):\n manager = Manager() \n if units is not None:\n # set units using a supplied dictionary\n for utype in units:\n if utype in manager.allowed_utypes:\n un = units[utype]\n # handle the identity of \"frequency\" and \"energy\"\n if utype==\"frequency\":\n utype=\"energy\"\n un = units[\"frequency\"]\n \n manager.set_current_units(utype,un)\n else:\n raise Exception(\"Unknown units type %s\" % utype)\n\n else:\n # reset units to the default\n for utype in manager.internal_units:\n if utype in manager.allowed_utypes:\n manager.set_current_units(utype,manager.internal_units[utype])\n else:\n raise Exception(\"Unknown units type %s\" % utype)","def unit2internal(src_unit: Union[str, float]):\n return _parse_unit(src_unit, conversion_factor=_conversion_factor_internal)","def get_converted_si_unit():\n units = request.args.get('units')\n response = ConvertUnit(units).convert()\n return jsonify(response)","def SBMLInferUnitsConverter_init():\n return _libsbml.SBMLInferUnitsConverter_init()","def convert_to_unit(self, data, unit):\n\n res = OrderedDict()\n\n # Loop over data and overwrite\n for ch in data:\n _idx = self.channels.index(ch)\n # Get data, scale and type of channel\n val, scale, _type = data[ch], self.daq_setup['devices']['adc']['ro_scales'][_idx], self.daq_setup['devices']['adc']['types'][_idx]\n # Adjust scale in case we're looking at SEM's sum signal; in this case current is multiplied by factor of 4\n scale *= 1 if _type != 'sem_sum' else 4\n\n res[ch] = val / 5.0 * scale * 1e-9 if unit == 'A' else val * 5.0 / 1e-9 / scale\n\n return res","def _Unit_get_base_equivalent_no_em(self, unit_system=None):\n\n unit_system = _sanitize_unit_system(unit_system, self)\n\n try:\n new_units = unit_system[self.dimensions]\n except MissingMKSCurrent:\n raise UnitsNotReducible(self.units, unit_system)\n return unyt.Unit(new_units, registry=self.registry)","def convert_to(self, units: str) -> None:\n if self.units == units:\n return\n\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\n msg = f\"\"\"Not a valid unit conversion. Valid destination units:\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\"\"\"\n raise ValueError(msg)\n\n if self.units == \"celsius\" and units == \"fahrenheit\":\n self._celsius_to_fahrenheit()\n elif self.units == \"m/s\" and units == \"km/h\":\n self._mps_to_kph()\n elif self.units == \"m/s\" and units == \"mph\":\n self._mps_to_mph()\n else:\n raise ValueError(\"Not a valid unit conversion.\")","def convert_units(cube, units):\n try:\n cube.convert_units(units)\n except ValueError:\n if not _try_special_conversions(cube, units):\n raise\n\n return cube","def _override_units_system(self):\n try:\n f = open(self.filename+\".units\")\n except OSError:\n return\n\n name_mapping = {'pos': 'distance', 'vel': 'velocity'}\n units_dict = {}\n\n for line in f:\n if (not line.startswith(\"#\")):\n if \":\" not in line:\n raise OSError(\"Unknown format for units file %r\"%(self.filename+\".units\"))\n else:\n t, u = list(map(str.strip,line.split(\":\")))\n t = name_mapping.get(t,t)\n units_dict[t] = u\n\n self.set_units_system(**units_dict)","def set_default_unit(unit):\n self.default_unit = unit","def get_unit(shared, unit_name):\n if (shared.config.get_safe('data', 'use_units') != 'off'):\n unit_val, unit_str = shared.config.get_safe_literal('units', unit_name,\n default=(1.0, ''))\n if unit_str:\n unit_str = ' [' + unit_str + ']'\n else:\n unit_val = 1.0\n unit_str = ''\n \n return unit_val, unit_str","def add_default_units(self, u: dict):\n # TODO: Could look at replacing dict with defined arguments\n # This would be a big API change\n try:\n self._default_units.set_units(**u)\n except TypeError:\n raise TypeError(\n \"Unexpected argument for base quantities found when creating UnitSet. \"\n \"Please ensure that units are only defined for the seven base quantities.\"\n )","def get_derived_unit(registry, key):\n if registry is None:\n return 1.0\n derived = {\n \"diffusivity\": registry[\"length\"] ** 2 / registry[\"time\"],\n \"electrical_mobility\": (\n registry[\"current\"] * registry[\"time\"] ** 2 / registry[\"mass\"]\n ),\n \"permittivity\": (\n registry[\"current\"] ** 2\n * registry[\"time\"] ** 4\n / (registry[\"length\"] ** 3 * registry[\"mass\"])\n ),\n \"charge\": registry[\"current\"] * registry[\"time\"],\n \"energy\": registry[\"mass\"] * registry[\"length\"] ** 2 / registry[\"time\"] ** 2,\n \"concentration\": registry[\"amount\"] / registry[\"length\"] ** 3,\n \"density\": registry[\"mass\"] / registry[\"length\"] ** 3,\n }\n derived[\"diffusion\"] = derived[\"diffusivity\"] # 'diffusion' is deprecated\n derived[\"radiolytic_yield\"] = registry[\"amount\"] / derived[\"energy\"]\n derived[\"doserate\"] = derived[\"energy\"] / registry[\"mass\"] / registry[\"time\"]\n derived[\"linear_energy_transfer\"] = derived[\"energy\"] / registry[\"length\"]\n\n try:\n return derived[key]\n except KeyError:\n return registry[key]","def create_unit(self, unit_type):\n unit = None\n\n if unit_type == 'ElfRider':\n unit = ElfRider()\n elif unit_type == 'Knight':\n unit = Knight()\n elif unit_type == \"DwarfFighter\":\n unit = DwarfFighter()\n elif unit_type == 'OrcRider':\n unit = OrcRider()\n elif unit_type == 'Fairy':\n unit = Fairy()\n elif unit_type == 'Wizard':\n unit = Wizard()\n elif unit_type == 'ElfLord':\n unit = ElfLord()\n elif unit_type == 'OrcFighter':\n unit = OrcFighter()\n\n return unit","def convert_units(celsius_value, units):\n if units == 0:\n return celsius_value\n if units == 1:\n return celsius_value * 1.8 + 32\n return celsius_value + 273.15","def unit(variable, unit):\n try:\n return myokit.Unit.convert(1, variable.unit(), unit)\n except myokit.IncompatibleUnitError:\n raise myokit.IncompatibleModelError(\n variable.model().name(),\n 'Incompatible units: ' + str(variable.unit()) + ' and '\n + str(unit) + '.')","def unit_system(self):\n val = self._stub.List(self._message).unit_system\n return map_unit_system[val]","def convert_units(unt, origunits):\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\n units = origunits\n convf = 1\n else:\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'met':\n units = 'feet'\n convf = 3.2808399\n else:\n units = origunits\n convf = 1\n else:\n if 'met' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'fee':\n units = 'meters'\n convf = 0.3048\n else:\n units = origunits\n convf = 1\n else:\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'kno':\n units = 'meters/sec'\n convf = 0.51444444\n else:\n units = origunits\n convf = 1\n else:\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'm/s':\n units = 'knots'\n convf = 1.9438445\n else:\n units = origunits\n convf = 1\n else:\n error('Unknown units')\n #\n return units, convf","def test_convert_same_unit():\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5","def convert_units(data, units):\n # Build the dictionary of units conversions\n convert = {'m' : [1.0, 0., 'm'], \n 'meter' : [1.0, 0., 'm'], \n 'deg C' : [1.0, 273.15, 'K'], \n 'Celsius' : [1.0, 273.15, 'K'], \n 'K' : [1.0, 0., 'K'],\n 'db' : [1.e4, 101325., 'Pa'], \n 'Pa' : [1.0, 0., 'Pa'],\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \n 'S/m': [1.0, 0., 'S/m'],\n 'mS/m' : [1.e-3, 0., 'S/m'],\n 'psu': [1.0, 0., 'psu'], \n 'salinity': [1.0, 0., 'psu'], \n 'kg/m^3': [1.0, 0., 'kg/m^3'], \n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \n 'm/s': [1.0, 0., 'm/s'], \n 'mg/l': [1.e-3, 0., 'kg/m^3'],\n 'meter second-1' : [1.0, 0., 'm/s'],\n 'm.s-1' : [1.0, 0., 'm/s'],\n 'pH units' : [1.0, 0., 'pH units'],\n 'MPa' : [1.e6, 0., 'Pa'],\n '--' : [1.0, 0., '--'],\n 'mD' : [9.869233e-16, 0., 'm^2'],\n 'um' : [1.e-6, 0., 'm'],\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\n 'wt.%' : [10., 0., 'psu'],\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\n 'm^2' : [1., 0., 'm^2'],\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \n } \n \n # Make sure the data are a numpy array and the units are a list\n if isinstance(data, float) or isinstance(data, int):\n data = np.array([data])\n if isinstance(data, list):\n data = np.array(data)\n if isinstance(units, str) or isinstance(units, unicode):\n units = [units]\n if units == None:\n units = ['']\n \n # Make sure you can slice through the columns: must be two-dimensional\n sh = data.shape\n data = np.atleast_2d(data)\n \n # Allow conversion of a row of data if all of the same unit\n if len(units) == 1 and data.shape[1] > 1:\n data = data.transpose()\n \n # Create an emtpy array to hold the output\n out_data = np.zeros(data.shape)\n out_units = []\n \n # Convert the units\n for i in range(len(units)):\n try:\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\n convert[units[i]][1]\n out_units += [convert[units[i]][2]]\n except KeyError:\n print('Do not know how to convert %s to mks units' % units[i])\n print('Continuing without converting these units...')\n out_data[:,i] = data[:,i]\n out_units += units[i]\n \n # Return the converted data in the original shape\n out_data = np.reshape(out_data, sh, 'C')\n return (out_data, out_units)","def reset_units(shared, *args):\n shared.config.remove_section('units')\n shared.config.add_section('units')\n \n return","def get_unit(self, unit_id: str) -> Mapping[str, Any]:\n return self.__get_one_by_id(\"units\", \"unit_id\", unit_id)","def init():\n return _libsbml.SBMLInferUnitsConverter_init()","def convert_unit(self, time_unit):\r\n\r\n self.time_unit = time_unit\r\n self._conversion_factor = time_unit_conversion[time_unit]","def to(self, new_unit, **kwargs):\n new_unit = u.Unit(new_unit)\n return self * (self.unit.to(new_unit, **kwargs) * new_unit / self.unit)","def resolve_units(obj, _):\n return obj.units.decode()","def test_convert_compatible_units(self):\n result = convert_units(self.arr, 'degC')\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\n expected_units = cf_units.Unit('degC')\n self.assertEquals(result.units, expected_units)\n self.assertArrayEqual(result.data, expected_data)","def convert_units(value, from_unit, to_unit, **args):\n\n # Check if units can be converted\n if not can_convert(from_unit, to_unit):\n return '[!] Units cannot be converted\\n'\n\n # Extract the numeric value from the string\n decimal_places = 2 # Set the default value of precision\n if \".\" in str(value):\n decimal_places = len(str(value)[str(value).index('.') + 1:])\n\n # Return the value if units are the same\n if from_unit == to_unit:\n return str(value) + \" \" + get_si(to_unit)\n\n responses = [\n check_time(value, from_unit, to_unit, decimal_places), # Time units\n check_metric_imperial(\n value,\n from_unit,\n to_unit,\n decimal_places), # Metric and Imperial units\n check_digital_storage(\n value,\n from_unit,\n to_unit,\n decimal_places\n ) # Digital storage units\n ]\n\n for response in responses:\n if response:\n return response\n\n # actually convert the units\n try:\n return str(round(convert(from_unit, to_unit, float(value), **args), decimal_places)) + \" \" + get_si(to_unit)\n except RequireAdditionalParamError as e:\n additional_unit = input(\"\\n[*] Enter an additional unit (choose between \" + str(e.additional_params) + \"): \")\n additional_value = float(input(\"\\n[*] Enter the value: \"))\n return convert_units(value, from_unit, to_unit, **{additional_unit: additional_value})\n except ConversionError as e:\n print(e.reason)","def unit_repr(self,utype=\"energy\",mode=\"current\"): \n \n \n if utype in self.allowed_utypes:\n if mode == \"current\":\n return self.units_repre[self.current_units[utype]]\n elif mode == \"internal\":\n return self.units_repre[self.internal_units[utype]]\n else:\n raise Exception(\"Unknown representation mode\")\n \n else:\n raise Exception(\"Unknown unit type\")","def cast_value(value, unit):\n if isinstance(value, u.Quantity):\n return value.to(unit)\n return value * unit","def backconvert_units(array, out_units):\n if out_units == \"None\" or out_units is None:\n return array\n else:\n raise Exception(\"Unsupported unit for bispectrum descriptors.\")","def convert_flux(nu, flux, target_unit):\n\n curr_unit = flux.unit\n\n if curr_unit.is_equivalent(u.erg / u.s):\n flux = flux / sed.distance ** 2\n elif curr_unit.is_equivalent(u.Jy):\n flux = flux * nu\n elif not curr_unit.is_equivalent(u.erg / u.cm ** 2 / u.s):\n raise Exception(\"Don't know how to convert {0} to ergs/cm^2/s\" % (flux.unit))\n\n # Convert to requested unit\n\n if target_unit.is_equivalent(u.erg / u.s):\n flux = flux * sed.distance ** 2\n elif target_unit.is_equivalent(u.Jy):\n flux = flux / nu\n elif not target_unit.is_equivalent(u.erg / u.cm ** 2 / u.s):\n raise Exception(\"Don't know how to convert %s to %s\" % (curr_unit, unit_flux))\n\n return flux.to(target_unit)","def convert(obj, unit, axis):\r\n return obj","def convert_units(array, in_units=\"None\"):\n if in_units == \"None\" or in_units is None:\n return array\n else:\n raise Exception(\"Unsupported unit for bispectrum descriptors.\")","def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)","def default_default_uom():\n ProductUom = Pool().get('product.uom')\n\n return ProductUom.search([('name', '=', 'Unit')])[0].id","async def on_unit_created(self, unit: Unit):","def convertUnits(self, unitMap):\n\n for child in Resonances.ancestryMembers:\n if getattr(self, child) is not None:\n getattr(self, child).convertUnits(unitMap)","def convert(self, value, units, newunits):\n return value * self._units[units] / self._units[newunits]","def _custom_unit_or_undef(\n self, primary_key: str, secondary_key: str\n ) -> str | None | UndefinedType:\n assert self.registry_entry\n if (\n (sensor_options := self.registry_entry.options.get(primary_key))\n and secondary_key in sensor_options\n and (device_class := self.device_class) in UNIT_CONVERTERS\n and self.native_unit_of_measurement\n in UNIT_CONVERTERS[device_class].VALID_UNITS\n and (custom_unit := sensor_options[secondary_key])\n in UNIT_CONVERTERS[device_class].VALID_UNITS\n ):\n return cast(str, custom_unit)\n return UNDEFINED","def convert_from_to(from_unit, to_unit, quantity):\n if not is_valid_unit(from_unit):\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\n if not is_valid_unit(to_unit):\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]","def parse_unit(self, unitelem) -> Unit:\n u = Unit()\n\n u.unitid = unitelem.attrib['id'].strip()\n div = unitelem.find('{*}divide')\n if div is not None:\n nom = div.find('{*}unitNumerator').find('{*}measure')\n denom = div.find('{*}unitDenominator').find('{*}measure')\n u.nom = re.sub('.*:', '', nom.text).lower()\n u.denom = re.sub('.*:', '', denom.text).lower()\n else:\n m = unitelem.find('{*}measure')\n u.nom = re.sub('.*:', '', m.text).lower()\n\n return u","def _get_or_create_unit(self,\n unit_name_truncated: str,\n unit_name_full: str) -> Squonk2AgentRv:\n # Get existing Units for our Organisation\n org_uuid: str = self.__org_record.uuid\n as_rv: AsApiRv = AsApi.get_units(self.__org_owner_as_token, org_id=org_uuid)\n if not as_rv.success:\n msg: str = as_rv.msg['error']\n _LOGGER.error('Failed to get Units for Organisation \"%s\"', org_uuid)\n return Squonk2AgentRv(success=False, msg=msg)\n # Iterate through them, looking for ours...\n _LOGGER.info('Got %s Units for Organisation \"%s\"', len(as_rv.msg['units']), org_uuid)\n for unit in as_rv.msg['units']:\n if unit['name'] == unit_name_truncated:\n unit_uuid: str = unit['id']\n _LOGGER.info('...and one was ours (%s)', unit_uuid)\n return Squonk2AgentRv(success=True, msg=unit_uuid)\n\n # Not found, create it...\n _LOGGER.info('No exiting Unit, creating NEW Unit \"%s\" (for \"%s\")',\n unit_name_full,\n unit_name_truncated)\n as_rv = AsApi.create_unit(self.__org_owner_as_token,\n unit_name=unit_name_truncated,\n org_id=org_uuid,\n billing_day=self.__unit_billing_day)\n if not as_rv.success:\n msg = as_rv.msg['error']\n _LOGGER.error('Failed to create Unit \"%s\" (for \"%s\")',\n unit_name_full, unit_name_truncated)\n return Squonk2AgentRv(success=False, msg=msg)\n\n unit_uuid = as_rv.msg['id']\n _LOGGER.info('Created NEW Unit \"%s\"', unit_uuid)\n return Squonk2AgentRv(success=True, msg=unit_uuid)","def parse_unit(unit_string):\n with warnings.catch_warnings():\n warnings.filterwarnings('ignore', module='astropy')\n try:\n unit = u.Unit(unit_string, parse_strict='raise')\n except ValueError:\n new_string = unit_string.replace('(cm-1)', 'kayser')\n log.debug(f'\\tValue Error, try {new_string}')\n unit = u.Unit(new_string,\n parse_strict='silent')\n log.debug(f'Parsed {unit_string} into {unit} ({type(unit)}).')\n return unit","def test_all_units(self):\n self.assertEqual(_unit_map(\"B\"), justbytes.B)\n self.assertEqual(_unit_map(\"KiB\"), justbytes.KiB)\n self.assertEqual(_unit_map(\"MiB\"), justbytes.MiB)\n self.assertEqual(_unit_map(\"GiB\"), justbytes.GiB)\n self.assertEqual(_unit_map(\"TiB\"), justbytes.TiB)\n self.assertEqual(_unit_map(\"PiB\"), justbytes.PiB)","def _to_units_container(a, registry=None):\n if isinstance(a, str) and \"=\" in a:\n return to_units_container(a.split(\"=\", 1)[1]), True\n return to_units_container(a, registry), False","def process_unit_input(in_,\n default_units: UnitLike = None,\n convert: bool = False,\n check_dims: bool = False,\n copy: bool = True,\n registry: unyt.UnitRegistry = None) -> unyt_array:\n parser = UnitInputParser(default_units=default_units,\n convert=convert,\n check_dims=check_dims,\n copy=copy,\n registry=registry)\n return parser.parse(in_)","def _to_lems_unit(unit):\n if type(unit) == str:\n strunit = unit\n else:\n strunit = unit.in_best_unit()\n strunit = strunit[3:] # here we substract '1. '\n strunit = strunit.replace('^', '') # in LEMS there is no ^\n return strunit","def UnitDefinition_convertToSI(*args):\n return _libsbml.UnitDefinition_convertToSI(*args)","def to(self, unit, equivalencies=[]):\n\n return super(BaseOneDSpectrum, self).to(unit, equivalencies, freq=None)","def test_temperature_to_imperial(self):\n self.assertEqual(\n 77,\n IMPERIAL_SYSTEM.temperature(77, IMPERIAL_SYSTEM.temperature_unit))\n self.assertEqual(\n 77,\n IMPERIAL_SYSTEM.temperature(25, METRIC_SYSTEM.temperature_unit))","def convert(self):\n return _libsbml.SBMLUnitsConverter_convert(self)","def test_as_type(self, wrapped_unit: MyType) -> None:\n # Arrange.\n # Create a new fake UnitType.\n other_type = mock.MagicMock()\n # Give it a name for easier debugging.\n other_type.__name__ = \"OtherType\"\n # A fake handler.\n handler = mock.Mock()\n\n # Register a cast for it.\n wrapped_unit.register_cast(other_type, handler)\n\n # A fake unit to convert.\n to_convert = MyUnit(wrapped_unit, 10)\n\n # Act.\n converted = wrapped_unit.as_type(to_convert, other_type)\n\n # Assert.\n # It should have called the handler.\n handler.assert_called_once_with(to_convert)\n assert converted == handler.return_value","def from_unit(cls, pulp_unit):\n unit_as_dict = copy.copy(pulp_unit.unit_key)\n unit_as_dict.update(pulp_unit.metadata)\n return cls.from_dict(unit_as_dict)","def _to(\n value: Union[\"Value\", \"ValueArray\"], units: Union[Unit, str], inplace: bool\n) -> Any:\n if value.units == units:\n return value\n\n if value.units is None:\n raise RuntimeError(\"Cannot convert with units=None\")\n\n try:\n units = next(\n imp_unit\n for imp_unit in value.implemented_units\n if units.lower() in imp_unit.aliases\n )\n\n except StopIteration:\n raise TypeError(\n f\"No viable unit conversion from {value.units} -> {units}\"\n )\n\n if not (isinstance(value, Value) or isinstance(value, ValueArray)):\n raise ValueError(\n f\"Cannot convert {value} to new units. Must be one of\"\n f\" Value of ValueArray\"\n )\n\n if isinstance(value, Value) and inplace:\n raise ValueError(\n \"Cannot modify a value inplace as floats are immutable\"\n )\n\n # Convert to the base unit, then to the new units\n c = float(units.conversion / value.units.conversion)\n\n new_value = value if inplace else value.copy()\n new_value *= c\n new_value.units = units\n\n return None if inplace else new_value","def convert_string_to_unit(s):\n \n if \":\" not in s:\n match = UNIT_RE.match(s)\n if match:\n s = \"%s:%s\"%match.groups()\n \n return Unit(s)","def convert_temp(orig_temp, units):\n switcher = {\n 'k': ((orig_temp - 32) * 5.0 / 9.0) + 273.15,\n 'c': (orig_temp - 32) * 5.0 / 9.0,\n 'f': orig_temp\n }\n temperature = switcher.get(units.lower())\n conversion = dict(original=orig_temp, units=units, temperature=temperature)\n return conversion","def set_unit(self,unit):\n self.unit = unit","def UnitKind_forName(*args):\n return _libsbml.UnitKind_forName(*args)","def run(self, registry):","def infer_original_units(self, dimensions):\n dimensions = units.Unit(dimensions)\n d = dimensions.dimensional_project(\n self._file_units_system + [\"a\", \"h\"])\n new_unit = reduce(lambda x, y: x * y, [\n a ** b for a, b in zip(self._file_units_system, d)])\n return new_unit","def to(self, units) -> Any:\n return _to(self, units, inplace=False)","def convert(self):\n return _libsbml.SBMLInferUnitsConverter_convert(self)","def convert( self, values, unit, toUnit ):\n\n if unit == toUnit: return values\n\n #-----------------------------------------------------------------\n # Check for unit validity \n #-----------------------------------------------------------------\n\n if unit != acuUnit.getBaseUnit( toUnit ):\n raise AcuDbAssistError, \"Invalid unit argument to get adbValues.\"\n \n #-----------------------------------------------------------------\n # Convert base unit to given unit\n #-----------------------------------------------------------------\n\n return self.cnvValues( values, unit, toUnit )","async def test_sensor_imperial_units(hass: HomeAssistant) -> None:\n hass.config.units = US_CUSTOMARY_SYSTEM\n await init_integration(hass)\n\n state = hass.states.get(\"sensor.home_cloud_ceiling\")\n assert state\n assert state.state == \"10498.687664042\"\n assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfLength.FEET\n\n state = hass.states.get(\"sensor.home_wind_speed\")\n assert state\n assert state.state == \"9.0\"\n assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfSpeed.MILES_PER_HOUR\n\n state = hass.states.get(\"sensor.home_realfeel_temperature\")\n assert state\n assert state.state == \"77.2\"\n assert (\n state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.FAHRENHEIT\n )","def in_unit_system(self, system):\n new_units = system.express_unit(self.unit)\n f = self.unit.conversion_factor_to(new_units)\n return self._change_units_with_factor(new_units, f)","def describe_a_library_of_units_converters_that():\n def blows_smoke():\n assert True\n\n def can_convert_psi_to_kpa():\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\n\n # def can_convert_kpa_to_psi():\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\n\n # def can_convert_mpg_to_lp100k():\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\n\n # def can_convert_lp100k_to_mpg():\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg","def Unit_convertToSI(*args):\n return _libsbml.Unit_convertToSI(*args)","def to(self, units):\n return _to(self, units, inplace=False)","def unit_of_measurement(self) -> str | None:\n # Highest priority, for registered entities: unit set by user,with fallback to\n # unit suggested by integration or secondary fallback to unit conversion rules\n if self._sensor_option_unit_of_measurement is not UNDEFINED:\n return self._sensor_option_unit_of_measurement\n\n # Second priority, for non registered entities: unit suggested by integration\n if not self.registry_entry and (\n suggested_unit_of_measurement := self.suggested_unit_of_measurement\n ):\n return suggested_unit_of_measurement\n\n # Third priority: Legacy temperature conversion, which applies\n # to both registered and non registered entities\n native_unit_of_measurement = self.native_unit_of_measurement\n\n if (\n self.device_class == SensorDeviceClass.TEMPERATURE\n and native_unit_of_measurement\n in {UnitOfTemperature.CELSIUS, UnitOfTemperature.FAHRENHEIT}\n ):\n return self.hass.config.units.temperature_unit\n\n # Fourth priority: Native unit\n return native_unit_of_measurement","def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6","def unit_type(self) -> str:","def tempConvert(temp, unit):\n if unit == 'F':\n celsius = (temp - 32) * 5 / 9\n return celsius\n else:\n return temp","def test_unit_conversion(self):\n self.cube_uv_down.convert_units(\"kW m-2\")\n scale_factor = 1.0\n expected = np.full_like(\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\n )\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\n self.assertArrayEqual(result.data, expected)"],"string":"[\n \"def _convert_unit(self, unit):\\n if unit in self.units:\\n return self.units[unit]\\n elif unit in unit_map:\\n return unit_map[unit]\\n else:\\n raise SBMLError('Unit not recognized: ' + str(unit))\",\n \"def test_convert_unit_with_custom_registry(test_df):\\n df = get_units_test_df(test_df).rename(unit={\\\"EJ/yr\\\": \\\"foo\\\"})\\n\\n # check that conversion fails with application registry\\n with pytest.raises(pint.UndefinedUnitError):\\n df.convert_unit(\\\"foo\\\", \\\"baz\\\")\\n\\n # define a custom unit registry\\n ureg = pint.UnitRegistry()\\n ureg.define(\\\"baz = [custom]\\\")\\n ureg.define(\\\"foo = 3 * baz\\\")\\n\\n exp = pd.Series([1.0, 6.0, 1.5, 9, 6, 21], name=\\\"value\\\")\\n assert_converted_units(df, \\\"foo\\\", \\\"baz\\\", exp, registry=ureg)\",\n \"def reload_unit_registry():\\n\\n import time\\n t_start = time.time()\\n\\n global _unit_registry\\n\\n _unit_registry = None\\n\\n reg = pint.UnitRegistry()\\n\\n # Define some \\\"standard\\\" additional units\\n reg.define('piece = 1')\\n reg.define('each = 1 = ea')\\n reg.define('dozen = 12 = dz')\\n reg.define('hundred = 100')\\n reg.define('thousand = 1000')\\n\\n # Allow for custom units to be defined in the database\\n try:\\n from common.models import CustomUnit\\n\\n for cu in CustomUnit.objects.all():\\n try:\\n reg.define(cu.fmt_string())\\n except Exception as e:\\n logger.error(f'Failed to load custom unit: {cu.fmt_string()} - {e}')\\n\\n # Once custom units are loaded, save registry\\n _unit_registry = reg\\n\\n except Exception:\\n # Database is not ready, or CustomUnit model is not available\\n pass\\n\\n dt = time.time() - t_start\\n logger.debug(f'Loaded unit registry in {dt:.3f}s')\\n\\n return reg\",\n \"def get_unit_registry():\\n\\n global _unit_registry\\n\\n # Cache the unit registry for speedier access\\n if _unit_registry is None:\\n return reload_unit_registry()\\n else:\\n return _unit_registry\",\n \"def unit_registry_to_human_readable(unit_registry):\\n if unit_registry is None:\\n return None\\n new_registry = {}\\n integer_one = 1\\n for k in SI_base_registry:\\n if unit_registry[k] is integer_one:\\n new_registry[k] = 1, 1\\n else:\\n dim_list = list(unit_registry[k].dimensionality)\\n if len(dim_list) != 1:\\n raise TypeError(\\\"Compound units not allowed: {}\\\".format(dim_list))\\n u_symbol = dim_list[0].u_symbol\\n new_registry[k] = float(unit_registry[k]), u_symbol\\n return new_registry\",\n \"def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\\n return process_unit_input(value, units, convert=True, registry=registry).v\",\n \"def load_unit(self, unit_id):\",\n \"def assign_unit(self):\\n self.units = {}\\n for unit in RADIAL_UNITS:\\n if unit.REPR == \\\"2th_deg\\\":\\n self.units[unit] = self.tth_deg\\n elif unit.REPR == \\\"2th_rad\\\":\\n self.units[unit] = self.tth_rad\\n elif unit.REPR == \\\"q_nm^-1\\\":\\n self.units[unit] = self.q_nm\\n elif unit.REPR == \\\"q_A^-1\\\":\\n self.units[unit] = self.q_A\\n elif unit.REPR == \\\"r_mm\\\":\\n self.units[unit] = self.r_mm\\n else:\\n logger.warning(\\\"Unit unknown to GUI %s\\\" % unit)\",\n \"def get_unit_system(system: SystemLike) -> unyt.UnitSystem:\\n if isinstance(system, unyt.UnitSystem):\\n return system\\n\\n try:\\n return unyt.unit_systems.unit_system_registry[str(system)]\\n except KeyError as exc:\\n raise UnitSystemNotFoundError(system) from exc\",\n \"def SBMLUnitsConverter_init():\\n return _libsbml.SBMLUnitsConverter_init()\",\n \"def get_unit_system(key: str) -> UnitSystem:\\n if key == _CONF_UNIT_SYSTEM_US_CUSTOMARY:\\n return US_CUSTOMARY_SYSTEM\\n if key == _CONF_UNIT_SYSTEM_METRIC:\\n return METRIC_SYSTEM\\n raise ValueError(f\\\"`{key}` is not a valid unit system key\\\")\",\n \"def convert_units(self, units):\\n self.unit_array = self.unit_array.to(units)\",\n \"def get_converted_unit(\\n self,\\n device_class: SensorDeviceClass | str | None,\\n original_unit: str | None,\\n ) -> str | None:\\n return self._conversions.get((device_class, original_unit))\",\n \"def _deprecated_unit_system(value: str) -> str:\\n\\n if value == _CONF_UNIT_SYSTEM_IMPERIAL:\\n # need to add warning in 2023.1\\n return _CONF_UNIT_SYSTEM_US_CUSTOMARY\\n return value\",\n \"def unit_to_dict(self, unused_unit):\\n raise Exception('Not implemented')\",\n \"def to_unit(self, unit):\\n unit = _find_unit(unit)\\n self.value = _convert_value(self.value, self.unit, unit)\\n self.unit = unit\",\n \"def units_to_fits(unit):\\n if unit is None:\\n unit = Unit('')\\n return unit.to_string(\\\"fits\\\").upper()\",\n \"def convertUnit(*args, fromUnit: AnyStr=\\\"\\\", toUnit: AnyStr=\\\"\\\", **kwargs)->float:\\n pass\",\n \"def _get_units_object(self, units):\\n if isinstance(units, cellml_units):\\n # We're done\\n pass\\n else:\\n units = amara_parse_cellml(unicode(units))\\n assert isinstance(units, cellml_units)\\n return units\",\n \"def convert(x, unit1, unit2):\\r\\n return conversions[unit1][unit2](x)\",\n \"def init():\\n return _libsbml.SBMLUnitsConverter_init()\",\n \"def save_unit(self, unit_name):\\n\\t\\tif unit_name:\\n\\t\\t\\tunit, created = Unit.objects.get_or_create(name = unit_name)\\n\\t\\t\\treturn unit\\n\\t\\telse:\\n\\t\\t\\treturn None\",\n \"def useUnits():\",\n \"def fits_to_units(unit_str):\\n unit_lookup = {\\n 'meters': 'm',\\n 'meter': 'm',\\n 'degrees': 'deg',\\n 'degree': 'deg',\\n 'hz': 'Hz',\\n 'hertz': 'Hz',\\n 'second': 's',\\n 'sec': 's',\\n 'secs': 's',\\n 'days': 'd',\\n 'day': 'd',\\n 'steradians': 'sr',\\n 'steradian': 'sr',\\n 'radians': 'rad',\\n 'radian': 'rad',\\n 'jy': 'Jy',\\n 'au': 'AU',\\n }\\n\\n try:\\n new_units = \\\"\\\"\\n\\n if unit_str is None:\\n unit_str = ''\\n unit_str = unit_str.lower()\\n unit_list = unit_str.split(\\\"/\\\")\\n\\n for uu in unit_list:\\n if uu.endswith(\\\"s\\\") and len(uu) > 1:\\n uu = uu[:-1]\\n corrected_unit = unit_lookup.get(uu, uu)\\n new_units += corrected_unit\\n new_units += \\\" / \\\"\\n new_units = new_units[:-3]\\n unit = Unit(new_units)\\n return unit\\n\\n except ValueError:\\n warnings.warn(\\\"Unknown unit: %s\\\" % new_units, UnitWarning)\\n return UnrecognizedUnit(unit_str)\",\n \"def _conversion_factor_internal(unit: str):\\n return globals()[unit]\",\n \"def to_base_unit(val: float, unit: str = \\\"\\\") -> float:\\n unit_scalar = UNITS.get(unit, None)\\n if not unit_scalar:\\n raise UnknownUnitError(f\\\"Unit '{unit}' is not supported\\\")\\n\\n return val * unit_scalar\",\n \"def _replace_units(original_units, values_by_name):\\n q = 1\\n for arg_name, exponent in original_units.items():\\n q = q * values_by_name[arg_name] ** exponent\\n\\n return getattr(q, \\\"_units\\\", UnitsContainer({}))\",\n \"def set_current_units(units=None):\\n manager = Manager() \\n if units is not None:\\n # set units using a supplied dictionary\\n for utype in units:\\n if utype in manager.allowed_utypes:\\n un = units[utype]\\n # handle the identity of \\\"frequency\\\" and \\\"energy\\\"\\n if utype==\\\"frequency\\\":\\n utype=\\\"energy\\\"\\n un = units[\\\"frequency\\\"]\\n \\n manager.set_current_units(utype,un)\\n else:\\n raise Exception(\\\"Unknown units type %s\\\" % utype)\\n\\n else:\\n # reset units to the default\\n for utype in manager.internal_units:\\n if utype in manager.allowed_utypes:\\n manager.set_current_units(utype,manager.internal_units[utype])\\n else:\\n raise Exception(\\\"Unknown units type %s\\\" % utype)\",\n \"def unit2internal(src_unit: Union[str, float]):\\n return _parse_unit(src_unit, conversion_factor=_conversion_factor_internal)\",\n \"def get_converted_si_unit():\\n units = request.args.get('units')\\n response = ConvertUnit(units).convert()\\n return jsonify(response)\",\n \"def SBMLInferUnitsConverter_init():\\n return _libsbml.SBMLInferUnitsConverter_init()\",\n \"def convert_to_unit(self, data, unit):\\n\\n res = OrderedDict()\\n\\n # Loop over data and overwrite\\n for ch in data:\\n _idx = self.channels.index(ch)\\n # Get data, scale and type of channel\\n val, scale, _type = data[ch], self.daq_setup['devices']['adc']['ro_scales'][_idx], self.daq_setup['devices']['adc']['types'][_idx]\\n # Adjust scale in case we're looking at SEM's sum signal; in this case current is multiplied by factor of 4\\n scale *= 1 if _type != 'sem_sum' else 4\\n\\n res[ch] = val / 5.0 * scale * 1e-9 if unit == 'A' else val * 5.0 / 1e-9 / scale\\n\\n return res\",\n \"def _Unit_get_base_equivalent_no_em(self, unit_system=None):\\n\\n unit_system = _sanitize_unit_system(unit_system, self)\\n\\n try:\\n new_units = unit_system[self.dimensions]\\n except MissingMKSCurrent:\\n raise UnitsNotReducible(self.units, unit_system)\\n return unyt.Unit(new_units, registry=self.registry)\",\n \"def convert_to(self, units: str) -> None:\\n if self.units == units:\\n return\\n\\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\\n msg = f\\\"\\\"\\\"Not a valid unit conversion. Valid destination units:\\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\\\"\\\"\\\"\\n raise ValueError(msg)\\n\\n if self.units == \\\"celsius\\\" and units == \\\"fahrenheit\\\":\\n self._celsius_to_fahrenheit()\\n elif self.units == \\\"m/s\\\" and units == \\\"km/h\\\":\\n self._mps_to_kph()\\n elif self.units == \\\"m/s\\\" and units == \\\"mph\\\":\\n self._mps_to_mph()\\n else:\\n raise ValueError(\\\"Not a valid unit conversion.\\\")\",\n \"def convert_units(cube, units):\\n try:\\n cube.convert_units(units)\\n except ValueError:\\n if not _try_special_conversions(cube, units):\\n raise\\n\\n return cube\",\n \"def _override_units_system(self):\\n try:\\n f = open(self.filename+\\\".units\\\")\\n except OSError:\\n return\\n\\n name_mapping = {'pos': 'distance', 'vel': 'velocity'}\\n units_dict = {}\\n\\n for line in f:\\n if (not line.startswith(\\\"#\\\")):\\n if \\\":\\\" not in line:\\n raise OSError(\\\"Unknown format for units file %r\\\"%(self.filename+\\\".units\\\"))\\n else:\\n t, u = list(map(str.strip,line.split(\\\":\\\")))\\n t = name_mapping.get(t,t)\\n units_dict[t] = u\\n\\n self.set_units_system(**units_dict)\",\n \"def set_default_unit(unit):\\n self.default_unit = unit\",\n \"def get_unit(shared, unit_name):\\n if (shared.config.get_safe('data', 'use_units') != 'off'):\\n unit_val, unit_str = shared.config.get_safe_literal('units', unit_name,\\n default=(1.0, ''))\\n if unit_str:\\n unit_str = ' [' + unit_str + ']'\\n else:\\n unit_val = 1.0\\n unit_str = ''\\n \\n return unit_val, unit_str\",\n \"def add_default_units(self, u: dict):\\n # TODO: Could look at replacing dict with defined arguments\\n # This would be a big API change\\n try:\\n self._default_units.set_units(**u)\\n except TypeError:\\n raise TypeError(\\n \\\"Unexpected argument for base quantities found when creating UnitSet. \\\"\\n \\\"Please ensure that units are only defined for the seven base quantities.\\\"\\n )\",\n \"def get_derived_unit(registry, key):\\n if registry is None:\\n return 1.0\\n derived = {\\n \\\"diffusivity\\\": registry[\\\"length\\\"] ** 2 / registry[\\\"time\\\"],\\n \\\"electrical_mobility\\\": (\\n registry[\\\"current\\\"] * registry[\\\"time\\\"] ** 2 / registry[\\\"mass\\\"]\\n ),\\n \\\"permittivity\\\": (\\n registry[\\\"current\\\"] ** 2\\n * registry[\\\"time\\\"] ** 4\\n / (registry[\\\"length\\\"] ** 3 * registry[\\\"mass\\\"])\\n ),\\n \\\"charge\\\": registry[\\\"current\\\"] * registry[\\\"time\\\"],\\n \\\"energy\\\": registry[\\\"mass\\\"] * registry[\\\"length\\\"] ** 2 / registry[\\\"time\\\"] ** 2,\\n \\\"concentration\\\": registry[\\\"amount\\\"] / registry[\\\"length\\\"] ** 3,\\n \\\"density\\\": registry[\\\"mass\\\"] / registry[\\\"length\\\"] ** 3,\\n }\\n derived[\\\"diffusion\\\"] = derived[\\\"diffusivity\\\"] # 'diffusion' is deprecated\\n derived[\\\"radiolytic_yield\\\"] = registry[\\\"amount\\\"] / derived[\\\"energy\\\"]\\n derived[\\\"doserate\\\"] = derived[\\\"energy\\\"] / registry[\\\"mass\\\"] / registry[\\\"time\\\"]\\n derived[\\\"linear_energy_transfer\\\"] = derived[\\\"energy\\\"] / registry[\\\"length\\\"]\\n\\n try:\\n return derived[key]\\n except KeyError:\\n return registry[key]\",\n \"def create_unit(self, unit_type):\\n unit = None\\n\\n if unit_type == 'ElfRider':\\n unit = ElfRider()\\n elif unit_type == 'Knight':\\n unit = Knight()\\n elif unit_type == \\\"DwarfFighter\\\":\\n unit = DwarfFighter()\\n elif unit_type == 'OrcRider':\\n unit = OrcRider()\\n elif unit_type == 'Fairy':\\n unit = Fairy()\\n elif unit_type == 'Wizard':\\n unit = Wizard()\\n elif unit_type == 'ElfLord':\\n unit = ElfLord()\\n elif unit_type == 'OrcFighter':\\n unit = OrcFighter()\\n\\n return unit\",\n \"def convert_units(celsius_value, units):\\n if units == 0:\\n return celsius_value\\n if units == 1:\\n return celsius_value * 1.8 + 32\\n return celsius_value + 273.15\",\n \"def unit(variable, unit):\\n try:\\n return myokit.Unit.convert(1, variable.unit(), unit)\\n except myokit.IncompatibleUnitError:\\n raise myokit.IncompatibleModelError(\\n variable.model().name(),\\n 'Incompatible units: ' + str(variable.unit()) + ' and '\\n + str(unit) + '.')\",\n \"def unit_system(self):\\n val = self._stub.List(self._message).unit_system\\n return map_unit_system[val]\",\n \"def convert_units(unt, origunits):\\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\\n units = origunits\\n convf = 1\\n else:\\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'met':\\n units = 'feet'\\n convf = 3.2808399\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'met' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'fee':\\n units = 'meters'\\n convf = 0.3048\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'kno':\\n units = 'meters/sec'\\n convf = 0.51444444\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'm/s':\\n units = 'knots'\\n convf = 1.9438445\\n else:\\n units = origunits\\n convf = 1\\n else:\\n error('Unknown units')\\n #\\n return units, convf\",\n \"def test_convert_same_unit():\\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5\",\n \"def convert_units(data, units):\\n # Build the dictionary of units conversions\\n convert = {'m' : [1.0, 0., 'm'], \\n 'meter' : [1.0, 0., 'm'], \\n 'deg C' : [1.0, 273.15, 'K'], \\n 'Celsius' : [1.0, 273.15, 'K'], \\n 'K' : [1.0, 0., 'K'],\\n 'db' : [1.e4, 101325., 'Pa'], \\n 'Pa' : [1.0, 0., 'Pa'],\\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \\n 'S/m': [1.0, 0., 'S/m'],\\n 'mS/m' : [1.e-3, 0., 'S/m'],\\n 'psu': [1.0, 0., 'psu'], \\n 'salinity': [1.0, 0., 'psu'], \\n 'kg/m^3': [1.0, 0., 'kg/m^3'], \\n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \\n 'm/s': [1.0, 0., 'm/s'], \\n 'mg/l': [1.e-3, 0., 'kg/m^3'],\\n 'meter second-1' : [1.0, 0., 'm/s'],\\n 'm.s-1' : [1.0, 0., 'm/s'],\\n 'pH units' : [1.0, 0., 'pH units'],\\n 'MPa' : [1.e6, 0., 'Pa'],\\n '--' : [1.0, 0., '--'],\\n 'mD' : [9.869233e-16, 0., 'm^2'],\\n 'um' : [1.e-6, 0., 'm'],\\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\\n 'wt.%' : [10., 0., 'psu'],\\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\\n 'm^2' : [1., 0., 'm^2'],\\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \\n } \\n \\n # Make sure the data are a numpy array and the units are a list\\n if isinstance(data, float) or isinstance(data, int):\\n data = np.array([data])\\n if isinstance(data, list):\\n data = np.array(data)\\n if isinstance(units, str) or isinstance(units, unicode):\\n units = [units]\\n if units == None:\\n units = ['']\\n \\n # Make sure you can slice through the columns: must be two-dimensional\\n sh = data.shape\\n data = np.atleast_2d(data)\\n \\n # Allow conversion of a row of data if all of the same unit\\n if len(units) == 1 and data.shape[1] > 1:\\n data = data.transpose()\\n \\n # Create an emtpy array to hold the output\\n out_data = np.zeros(data.shape)\\n out_units = []\\n \\n # Convert the units\\n for i in range(len(units)):\\n try:\\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\\\\n convert[units[i]][1]\\n out_units += [convert[units[i]][2]]\\n except KeyError:\\n print('Do not know how to convert %s to mks units' % units[i])\\n print('Continuing without converting these units...')\\n out_data[:,i] = data[:,i]\\n out_units += units[i]\\n \\n # Return the converted data in the original shape\\n out_data = np.reshape(out_data, sh, 'C')\\n return (out_data, out_units)\",\n \"def reset_units(shared, *args):\\n shared.config.remove_section('units')\\n shared.config.add_section('units')\\n \\n return\",\n \"def get_unit(self, unit_id: str) -> Mapping[str, Any]:\\n return self.__get_one_by_id(\\\"units\\\", \\\"unit_id\\\", unit_id)\",\n \"def init():\\n return _libsbml.SBMLInferUnitsConverter_init()\",\n \"def convert_unit(self, time_unit):\\r\\n\\r\\n self.time_unit = time_unit\\r\\n self._conversion_factor = time_unit_conversion[time_unit]\",\n \"def to(self, new_unit, **kwargs):\\n new_unit = u.Unit(new_unit)\\n return self * (self.unit.to(new_unit, **kwargs) * new_unit / self.unit)\",\n \"def resolve_units(obj, _):\\n return obj.units.decode()\",\n \"def test_convert_compatible_units(self):\\n result = convert_units(self.arr, 'degC')\\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\\n expected_units = cf_units.Unit('degC')\\n self.assertEquals(result.units, expected_units)\\n self.assertArrayEqual(result.data, expected_data)\",\n \"def convert_units(value, from_unit, to_unit, **args):\\n\\n # Check if units can be converted\\n if not can_convert(from_unit, to_unit):\\n return '[!] Units cannot be converted\\\\n'\\n\\n # Extract the numeric value from the string\\n decimal_places = 2 # Set the default value of precision\\n if \\\".\\\" in str(value):\\n decimal_places = len(str(value)[str(value).index('.') + 1:])\\n\\n # Return the value if units are the same\\n if from_unit == to_unit:\\n return str(value) + \\\" \\\" + get_si(to_unit)\\n\\n responses = [\\n check_time(value, from_unit, to_unit, decimal_places), # Time units\\n check_metric_imperial(\\n value,\\n from_unit,\\n to_unit,\\n decimal_places), # Metric and Imperial units\\n check_digital_storage(\\n value,\\n from_unit,\\n to_unit,\\n decimal_places\\n ) # Digital storage units\\n ]\\n\\n for response in responses:\\n if response:\\n return response\\n\\n # actually convert the units\\n try:\\n return str(round(convert(from_unit, to_unit, float(value), **args), decimal_places)) + \\\" \\\" + get_si(to_unit)\\n except RequireAdditionalParamError as e:\\n additional_unit = input(\\\"\\\\n[*] Enter an additional unit (choose between \\\" + str(e.additional_params) + \\\"): \\\")\\n additional_value = float(input(\\\"\\\\n[*] Enter the value: \\\"))\\n return convert_units(value, from_unit, to_unit, **{additional_unit: additional_value})\\n except ConversionError as e:\\n print(e.reason)\",\n \"def unit_repr(self,utype=\\\"energy\\\",mode=\\\"current\\\"): \\n \\n \\n if utype in self.allowed_utypes:\\n if mode == \\\"current\\\":\\n return self.units_repre[self.current_units[utype]]\\n elif mode == \\\"internal\\\":\\n return self.units_repre[self.internal_units[utype]]\\n else:\\n raise Exception(\\\"Unknown representation mode\\\")\\n \\n else:\\n raise Exception(\\\"Unknown unit type\\\")\",\n \"def cast_value(value, unit):\\n if isinstance(value, u.Quantity):\\n return value.to(unit)\\n return value * unit\",\n \"def backconvert_units(array, out_units):\\n if out_units == \\\"None\\\" or out_units is None:\\n return array\\n else:\\n raise Exception(\\\"Unsupported unit for bispectrum descriptors.\\\")\",\n \"def convert_flux(nu, flux, target_unit):\\n\\n curr_unit = flux.unit\\n\\n if curr_unit.is_equivalent(u.erg / u.s):\\n flux = flux / sed.distance ** 2\\n elif curr_unit.is_equivalent(u.Jy):\\n flux = flux * nu\\n elif not curr_unit.is_equivalent(u.erg / u.cm ** 2 / u.s):\\n raise Exception(\\\"Don't know how to convert {0} to ergs/cm^2/s\\\" % (flux.unit))\\n\\n # Convert to requested unit\\n\\n if target_unit.is_equivalent(u.erg / u.s):\\n flux = flux * sed.distance ** 2\\n elif target_unit.is_equivalent(u.Jy):\\n flux = flux / nu\\n elif not target_unit.is_equivalent(u.erg / u.cm ** 2 / u.s):\\n raise Exception(\\\"Don't know how to convert %s to %s\\\" % (curr_unit, unit_flux))\\n\\n return flux.to(target_unit)\",\n \"def convert(obj, unit, axis):\\r\\n return obj\",\n \"def convert_units(array, in_units=\\\"None\\\"):\\n if in_units == \\\"None\\\" or in_units is None:\\n return array\\n else:\\n raise Exception(\\\"Unsupported unit for bispectrum descriptors.\\\")\",\n \"def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)\",\n \"def default_default_uom():\\n ProductUom = Pool().get('product.uom')\\n\\n return ProductUom.search([('name', '=', 'Unit')])[0].id\",\n \"async def on_unit_created(self, unit: Unit):\",\n \"def convertUnits(self, unitMap):\\n\\n for child in Resonances.ancestryMembers:\\n if getattr(self, child) is not None:\\n getattr(self, child).convertUnits(unitMap)\",\n \"def convert(self, value, units, newunits):\\n return value * self._units[units] / self._units[newunits]\",\n \"def _custom_unit_or_undef(\\n self, primary_key: str, secondary_key: str\\n ) -> str | None | UndefinedType:\\n assert self.registry_entry\\n if (\\n (sensor_options := self.registry_entry.options.get(primary_key))\\n and secondary_key in sensor_options\\n and (device_class := self.device_class) in UNIT_CONVERTERS\\n and self.native_unit_of_measurement\\n in UNIT_CONVERTERS[device_class].VALID_UNITS\\n and (custom_unit := sensor_options[secondary_key])\\n in UNIT_CONVERTERS[device_class].VALID_UNITS\\n ):\\n return cast(str, custom_unit)\\n return UNDEFINED\",\n \"def convert_from_to(from_unit, to_unit, quantity):\\n if not is_valid_unit(from_unit):\\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\\n if not is_valid_unit(to_unit):\\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]\",\n \"def parse_unit(self, unitelem) -> Unit:\\n u = Unit()\\n\\n u.unitid = unitelem.attrib['id'].strip()\\n div = unitelem.find('{*}divide')\\n if div is not None:\\n nom = div.find('{*}unitNumerator').find('{*}measure')\\n denom = div.find('{*}unitDenominator').find('{*}measure')\\n u.nom = re.sub('.*:', '', nom.text).lower()\\n u.denom = re.sub('.*:', '', denom.text).lower()\\n else:\\n m = unitelem.find('{*}measure')\\n u.nom = re.sub('.*:', '', m.text).lower()\\n\\n return u\",\n \"def _get_or_create_unit(self,\\n unit_name_truncated: str,\\n unit_name_full: str) -> Squonk2AgentRv:\\n # Get existing Units for our Organisation\\n org_uuid: str = self.__org_record.uuid\\n as_rv: AsApiRv = AsApi.get_units(self.__org_owner_as_token, org_id=org_uuid)\\n if not as_rv.success:\\n msg: str = as_rv.msg['error']\\n _LOGGER.error('Failed to get Units for Organisation \\\"%s\\\"', org_uuid)\\n return Squonk2AgentRv(success=False, msg=msg)\\n # Iterate through them, looking for ours...\\n _LOGGER.info('Got %s Units for Organisation \\\"%s\\\"', len(as_rv.msg['units']), org_uuid)\\n for unit in as_rv.msg['units']:\\n if unit['name'] == unit_name_truncated:\\n unit_uuid: str = unit['id']\\n _LOGGER.info('...and one was ours (%s)', unit_uuid)\\n return Squonk2AgentRv(success=True, msg=unit_uuid)\\n\\n # Not found, create it...\\n _LOGGER.info('No exiting Unit, creating NEW Unit \\\"%s\\\" (for \\\"%s\\\")',\\n unit_name_full,\\n unit_name_truncated)\\n as_rv = AsApi.create_unit(self.__org_owner_as_token,\\n unit_name=unit_name_truncated,\\n org_id=org_uuid,\\n billing_day=self.__unit_billing_day)\\n if not as_rv.success:\\n msg = as_rv.msg['error']\\n _LOGGER.error('Failed to create Unit \\\"%s\\\" (for \\\"%s\\\")',\\n unit_name_full, unit_name_truncated)\\n return Squonk2AgentRv(success=False, msg=msg)\\n\\n unit_uuid = as_rv.msg['id']\\n _LOGGER.info('Created NEW Unit \\\"%s\\\"', unit_uuid)\\n return Squonk2AgentRv(success=True, msg=unit_uuid)\",\n \"def parse_unit(unit_string):\\n with warnings.catch_warnings():\\n warnings.filterwarnings('ignore', module='astropy')\\n try:\\n unit = u.Unit(unit_string, parse_strict='raise')\\n except ValueError:\\n new_string = unit_string.replace('(cm-1)', 'kayser')\\n log.debug(f'\\\\tValue Error, try {new_string}')\\n unit = u.Unit(new_string,\\n parse_strict='silent')\\n log.debug(f'Parsed {unit_string} into {unit} ({type(unit)}).')\\n return unit\",\n \"def test_all_units(self):\\n self.assertEqual(_unit_map(\\\"B\\\"), justbytes.B)\\n self.assertEqual(_unit_map(\\\"KiB\\\"), justbytes.KiB)\\n self.assertEqual(_unit_map(\\\"MiB\\\"), justbytes.MiB)\\n self.assertEqual(_unit_map(\\\"GiB\\\"), justbytes.GiB)\\n self.assertEqual(_unit_map(\\\"TiB\\\"), justbytes.TiB)\\n self.assertEqual(_unit_map(\\\"PiB\\\"), justbytes.PiB)\",\n \"def _to_units_container(a, registry=None):\\n if isinstance(a, str) and \\\"=\\\" in a:\\n return to_units_container(a.split(\\\"=\\\", 1)[1]), True\\n return to_units_container(a, registry), False\",\n \"def process_unit_input(in_,\\n default_units: UnitLike = None,\\n convert: bool = False,\\n check_dims: bool = False,\\n copy: bool = True,\\n registry: unyt.UnitRegistry = None) -> unyt_array:\\n parser = UnitInputParser(default_units=default_units,\\n convert=convert,\\n check_dims=check_dims,\\n copy=copy,\\n registry=registry)\\n return parser.parse(in_)\",\n \"def _to_lems_unit(unit):\\n if type(unit) == str:\\n strunit = unit\\n else:\\n strunit = unit.in_best_unit()\\n strunit = strunit[3:] # here we substract '1. '\\n strunit = strunit.replace('^', '') # in LEMS there is no ^\\n return strunit\",\n \"def UnitDefinition_convertToSI(*args):\\n return _libsbml.UnitDefinition_convertToSI(*args)\",\n \"def to(self, unit, equivalencies=[]):\\n\\n return super(BaseOneDSpectrum, self).to(unit, equivalencies, freq=None)\",\n \"def test_temperature_to_imperial(self):\\n self.assertEqual(\\n 77,\\n IMPERIAL_SYSTEM.temperature(77, IMPERIAL_SYSTEM.temperature_unit))\\n self.assertEqual(\\n 77,\\n IMPERIAL_SYSTEM.temperature(25, METRIC_SYSTEM.temperature_unit))\",\n \"def convert(self):\\n return _libsbml.SBMLUnitsConverter_convert(self)\",\n \"def test_as_type(self, wrapped_unit: MyType) -> None:\\n # Arrange.\\n # Create a new fake UnitType.\\n other_type = mock.MagicMock()\\n # Give it a name for easier debugging.\\n other_type.__name__ = \\\"OtherType\\\"\\n # A fake handler.\\n handler = mock.Mock()\\n\\n # Register a cast for it.\\n wrapped_unit.register_cast(other_type, handler)\\n\\n # A fake unit to convert.\\n to_convert = MyUnit(wrapped_unit, 10)\\n\\n # Act.\\n converted = wrapped_unit.as_type(to_convert, other_type)\\n\\n # Assert.\\n # It should have called the handler.\\n handler.assert_called_once_with(to_convert)\\n assert converted == handler.return_value\",\n \"def from_unit(cls, pulp_unit):\\n unit_as_dict = copy.copy(pulp_unit.unit_key)\\n unit_as_dict.update(pulp_unit.metadata)\\n return cls.from_dict(unit_as_dict)\",\n \"def _to(\\n value: Union[\\\"Value\\\", \\\"ValueArray\\\"], units: Union[Unit, str], inplace: bool\\n) -> Any:\\n if value.units == units:\\n return value\\n\\n if value.units is None:\\n raise RuntimeError(\\\"Cannot convert with units=None\\\")\\n\\n try:\\n units = next(\\n imp_unit\\n for imp_unit in value.implemented_units\\n if units.lower() in imp_unit.aliases\\n )\\n\\n except StopIteration:\\n raise TypeError(\\n f\\\"No viable unit conversion from {value.units} -> {units}\\\"\\n )\\n\\n if not (isinstance(value, Value) or isinstance(value, ValueArray)):\\n raise ValueError(\\n f\\\"Cannot convert {value} to new units. Must be one of\\\"\\n f\\\" Value of ValueArray\\\"\\n )\\n\\n if isinstance(value, Value) and inplace:\\n raise ValueError(\\n \\\"Cannot modify a value inplace as floats are immutable\\\"\\n )\\n\\n # Convert to the base unit, then to the new units\\n c = float(units.conversion / value.units.conversion)\\n\\n new_value = value if inplace else value.copy()\\n new_value *= c\\n new_value.units = units\\n\\n return None if inplace else new_value\",\n \"def convert_string_to_unit(s):\\n \\n if \\\":\\\" not in s:\\n match = UNIT_RE.match(s)\\n if match:\\n s = \\\"%s:%s\\\"%match.groups()\\n \\n return Unit(s)\",\n \"def convert_temp(orig_temp, units):\\n switcher = {\\n 'k': ((orig_temp - 32) * 5.0 / 9.0) + 273.15,\\n 'c': (orig_temp - 32) * 5.0 / 9.0,\\n 'f': orig_temp\\n }\\n temperature = switcher.get(units.lower())\\n conversion = dict(original=orig_temp, units=units, temperature=temperature)\\n return conversion\",\n \"def set_unit(self,unit):\\n self.unit = unit\",\n \"def UnitKind_forName(*args):\\n return _libsbml.UnitKind_forName(*args)\",\n \"def run(self, registry):\",\n \"def infer_original_units(self, dimensions):\\n dimensions = units.Unit(dimensions)\\n d = dimensions.dimensional_project(\\n self._file_units_system + [\\\"a\\\", \\\"h\\\"])\\n new_unit = reduce(lambda x, y: x * y, [\\n a ** b for a, b in zip(self._file_units_system, d)])\\n return new_unit\",\n \"def to(self, units) -> Any:\\n return _to(self, units, inplace=False)\",\n \"def convert(self):\\n return _libsbml.SBMLInferUnitsConverter_convert(self)\",\n \"def convert( self, values, unit, toUnit ):\\n\\n if unit == toUnit: return values\\n\\n #-----------------------------------------------------------------\\n # Check for unit validity \\n #-----------------------------------------------------------------\\n\\n if unit != acuUnit.getBaseUnit( toUnit ):\\n raise AcuDbAssistError, \\\"Invalid unit argument to get adbValues.\\\"\\n \\n #-----------------------------------------------------------------\\n # Convert base unit to given unit\\n #-----------------------------------------------------------------\\n\\n return self.cnvValues( values, unit, toUnit )\",\n \"async def test_sensor_imperial_units(hass: HomeAssistant) -> None:\\n hass.config.units = US_CUSTOMARY_SYSTEM\\n await init_integration(hass)\\n\\n state = hass.states.get(\\\"sensor.home_cloud_ceiling\\\")\\n assert state\\n assert state.state == \\\"10498.687664042\\\"\\n assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfLength.FEET\\n\\n state = hass.states.get(\\\"sensor.home_wind_speed\\\")\\n assert state\\n assert state.state == \\\"9.0\\\"\\n assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfSpeed.MILES_PER_HOUR\\n\\n state = hass.states.get(\\\"sensor.home_realfeel_temperature\\\")\\n assert state\\n assert state.state == \\\"77.2\\\"\\n assert (\\n state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.FAHRENHEIT\\n )\",\n \"def in_unit_system(self, system):\\n new_units = system.express_unit(self.unit)\\n f = self.unit.conversion_factor_to(new_units)\\n return self._change_units_with_factor(new_units, f)\",\n \"def describe_a_library_of_units_converters_that():\\n def blows_smoke():\\n assert True\\n\\n def can_convert_psi_to_kpa():\\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\\n\\n # def can_convert_kpa_to_psi():\\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\\n\\n # def can_convert_mpg_to_lp100k():\\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\\n\\n # def can_convert_lp100k_to_mpg():\\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg\",\n \"def Unit_convertToSI(*args):\\n return _libsbml.Unit_convertToSI(*args)\",\n \"def to(self, units):\\n return _to(self, units, inplace=False)\",\n \"def unit_of_measurement(self) -> str | None:\\n # Highest priority, for registered entities: unit set by user,with fallback to\\n # unit suggested by integration or secondary fallback to unit conversion rules\\n if self._sensor_option_unit_of_measurement is not UNDEFINED:\\n return self._sensor_option_unit_of_measurement\\n\\n # Second priority, for non registered entities: unit suggested by integration\\n if not self.registry_entry and (\\n suggested_unit_of_measurement := self.suggested_unit_of_measurement\\n ):\\n return suggested_unit_of_measurement\\n\\n # Third priority: Legacy temperature conversion, which applies\\n # to both registered and non registered entities\\n native_unit_of_measurement = self.native_unit_of_measurement\\n\\n if (\\n self.device_class == SensorDeviceClass.TEMPERATURE\\n and native_unit_of_measurement\\n in {UnitOfTemperature.CELSIUS, UnitOfTemperature.FAHRENHEIT}\\n ):\\n return self.hass.config.units.temperature_unit\\n\\n # Fourth priority: Native unit\\n return native_unit_of_measurement\",\n \"def convert_units(self):\\n for prod in (\\\"ier\\\", \\\"ier_inc_rain\\\"):\\n self.data[prod].data[:] /= 1e6\",\n \"def unit_type(self) -> str:\",\n \"def tempConvert(temp, unit):\\n if unit == 'F':\\n celsius = (temp - 32) * 5 / 9\\n return celsius\\n else:\\n return temp\",\n \"def test_unit_conversion(self):\\n self.cube_uv_down.convert_units(\\\"kW m-2\\\")\\n scale_factor = 1.0\\n expected = np.full_like(\\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\\n )\\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\\n self.assertArrayEqual(result.data, expected)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.687325","0.684293","0.66271764","0.6505694","0.6295247","0.6124371","0.5856852","0.58415043","0.58247006","0.5799204","0.57857335","0.5764567","0.5676909","0.56088245","0.5580017","0.5564396","0.55641305","0.55638456","0.5550743","0.55411625","0.5519221","0.5517461","0.5513661","0.5505084","0.54648685","0.5458384","0.544959","0.5437595","0.5415615","0.5415115","0.5414138","0.5403847","0.53900003","0.538122","0.53712773","0.53329825","0.53321284","0.53298044","0.5317046","0.5316627","0.53125286","0.53043056","0.5267445","0.52544504","0.52529866","0.5250458","0.52196217","0.52043414","0.5179642","0.5177906","0.51650786","0.51619035","0.5143085","0.5142244","0.5140657","0.5139866","0.51343954","0.5132487","0.51314896","0.51237875","0.5121986","0.51204336","0.5119764","0.5104191","0.50902414","0.50802225","0.50798863","0.50571454","0.5054307","0.50519544","0.50502604","0.5047287","0.50340366","0.5032867","0.5032313","0.5028245","0.50259465","0.5006496","0.4997804","0.4997663","0.49963528","0.49963152","0.49954185","0.49951133","0.49794555","0.49700928","0.49637896","0.49630204","0.49591485","0.4956695","0.49497634","0.49442208","0.49417177","0.49413466","0.49401155","0.49365112","0.49111253","0.4904822","0.489889","0.4888819","0.48822424"],"string":"[\n \"0.687325\",\n \"0.684293\",\n \"0.66271764\",\n \"0.6505694\",\n \"0.6295247\",\n \"0.6124371\",\n \"0.5856852\",\n \"0.58415043\",\n \"0.58247006\",\n \"0.5799204\",\n \"0.57857335\",\n \"0.5764567\",\n \"0.5676909\",\n \"0.56088245\",\n \"0.5580017\",\n \"0.5564396\",\n \"0.55641305\",\n \"0.55638456\",\n \"0.5550743\",\n \"0.55411625\",\n \"0.5519221\",\n \"0.5517461\",\n \"0.5513661\",\n \"0.5505084\",\n \"0.54648685\",\n \"0.5458384\",\n \"0.544959\",\n \"0.5437595\",\n \"0.5415615\",\n \"0.5415115\",\n \"0.5414138\",\n \"0.5403847\",\n \"0.53900003\",\n \"0.538122\",\n \"0.53712773\",\n \"0.53329825\",\n \"0.53321284\",\n \"0.53298044\",\n \"0.5317046\",\n \"0.5316627\",\n \"0.53125286\",\n \"0.53043056\",\n \"0.5267445\",\n \"0.52544504\",\n \"0.52529866\",\n \"0.5250458\",\n \"0.52196217\",\n \"0.52043414\",\n \"0.5179642\",\n \"0.5177906\",\n \"0.51650786\",\n \"0.51619035\",\n \"0.5143085\",\n \"0.5142244\",\n \"0.5140657\",\n \"0.5139866\",\n \"0.51343954\",\n \"0.5132487\",\n \"0.51314896\",\n \"0.51237875\",\n \"0.5121986\",\n \"0.51204336\",\n \"0.5119764\",\n \"0.5104191\",\n \"0.50902414\",\n \"0.50802225\",\n \"0.50798863\",\n \"0.50571454\",\n \"0.5054307\",\n \"0.50519544\",\n \"0.50502604\",\n \"0.5047287\",\n \"0.50340366\",\n \"0.5032867\",\n \"0.5032313\",\n \"0.5028245\",\n \"0.50259465\",\n \"0.5006496\",\n \"0.4997804\",\n \"0.4997663\",\n \"0.49963528\",\n \"0.49963152\",\n \"0.49954185\",\n \"0.49951133\",\n \"0.49794555\",\n \"0.49700928\",\n \"0.49637896\",\n \"0.49630204\",\n \"0.49591485\",\n \"0.4956695\",\n \"0.49497634\",\n \"0.49442208\",\n \"0.49417177\",\n \"0.49413466\",\n \"0.49401155\",\n \"0.49365112\",\n \"0.49111253\",\n \"0.4904822\",\n \"0.489889\",\n \"0.4888819\",\n \"0.48822424\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14868,"cells":{"query":{"kind":"string","value":"Convert unit with definition loaded from `IAMconsortium/units` repo"},"document":{"kind":"string","value":"def test_convert_unit_from_repo(test_df):\n df = get_units_test_df(test_df)\n exp = pd.Series([1.0, 6.0, 17.06, 102.361, 68.241, 238.843], name=\"value\")\n assert_converted_units(df, \"EJ/yr\", \"Mtce/yr\", exp)"},"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 _convert_unit(self, unit):\n if unit in self.units:\n return self.units[unit]\n elif unit in unit_map:\n return unit_map[unit]\n else:\n raise SBMLError('Unit not recognized: ' + str(unit))","def _get_units_object(self, units):\n if isinstance(units, cellml_units):\n # We're done\n pass\n else:\n units = amara_parse_cellml(unicode(units))\n assert isinstance(units, cellml_units)\n return units","def fits_to_units(unit_str):\n unit_lookup = {\n 'meters': 'm',\n 'meter': 'm',\n 'degrees': 'deg',\n 'degree': 'deg',\n 'hz': 'Hz',\n 'hertz': 'Hz',\n 'second': 's',\n 'sec': 's',\n 'secs': 's',\n 'days': 'd',\n 'day': 'd',\n 'steradians': 'sr',\n 'steradian': 'sr',\n 'radians': 'rad',\n 'radian': 'rad',\n 'jy': 'Jy',\n 'au': 'AU',\n }\n\n try:\n new_units = \"\"\n\n if unit_str is None:\n unit_str = ''\n unit_str = unit_str.lower()\n unit_list = unit_str.split(\"/\")\n\n for uu in unit_list:\n if uu.endswith(\"s\") and len(uu) > 1:\n uu = uu[:-1]\n corrected_unit = unit_lookup.get(uu, uu)\n new_units += corrected_unit\n new_units += \" / \"\n new_units = new_units[:-3]\n unit = Unit(new_units)\n return unit\n\n except ValueError:\n warnings.warn(\"Unknown unit: %s\" % new_units, UnitWarning)\n return UnrecognizedUnit(unit_str)","def resolve_units(obj, _):\n return obj.units.decode()","def convert_units(unt, origunits):\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\n units = origunits\n convf = 1\n else:\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'met':\n units = 'feet'\n convf = 3.2808399\n else:\n units = origunits\n convf = 1\n else:\n if 'met' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'fee':\n units = 'meters'\n convf = 0.3048\n else:\n units = origunits\n convf = 1\n else:\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'kno':\n units = 'meters/sec'\n convf = 0.51444444\n else:\n units = origunits\n convf = 1\n else:\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'm/s':\n units = 'knots'\n convf = 1.9438445\n else:\n units = origunits\n convf = 1\n else:\n error('Unknown units')\n #\n return units, convf","def units_to_fits(unit):\n if unit is None:\n unit = Unit('')\n return unit.to_string(\"fits\").upper()","def parse_unit(self, unitelem) -> Unit:\n u = Unit()\n\n u.unitid = unitelem.attrib['id'].strip()\n div = unitelem.find('{*}divide')\n if div is not None:\n nom = div.find('{*}unitNumerator').find('{*}measure')\n denom = div.find('{*}unitDenominator').find('{*}measure')\n u.nom = re.sub('.*:', '', nom.text).lower()\n u.denom = re.sub('.*:', '', denom.text).lower()\n else:\n m = unitelem.find('{*}measure')\n u.nom = re.sub('.*:', '', m.text).lower()\n\n return u","def unit2internal(src_unit: Union[str, float]):\n return _parse_unit(src_unit, conversion_factor=_conversion_factor_internal)","def convertUnit(*args, fromUnit: AnyStr=\"\", toUnit: AnyStr=\"\", **kwargs)->float:\n pass","def to_unit(self, unit):\n unit = _find_unit(unit)\n self.value = _convert_value(self.value, self.unit, unit)\n self.unit = unit","def convert_units(self, units):\n self.unit_array = self.unit_array.to(units)","def _to_lems_unit(unit):\n if type(unit) == str:\n strunit = unit\n else:\n strunit = unit.in_best_unit()\n strunit = strunit[3:] # here we substract '1. '\n strunit = strunit.replace('^', '') # in LEMS there is no ^\n return strunit","def test_convert_compatible_units(self):\n result = convert_units(self.arr, 'degC')\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\n expected_units = cf_units.Unit('degC')\n self.assertEquals(result.units, expected_units)\n self.assertArrayEqual(result.data, expected_data)","def load_unit(self, unit_id):","def _fix_units(cube, definition):\n\n if cube.var_name != 'pr':\n cube.convert_units(definition.units)","def unit(variable, unit):\n try:\n return myokit.Unit.convert(1, variable.unit(), unit)\n except myokit.IncompatibleUnitError:\n raise myokit.IncompatibleModelError(\n variable.model().name(),\n 'Incompatible units: ' + str(variable.unit()) + ' and '\n + str(unit) + '.')","def test_change_units(self):\n s = State(\"water\", T=Q_(100, \"degC\"), p=Q_(1.0, \"atm\"), units=\"EE\")\n assert s.units == \"EE\"\n s.units = \"SI\"\n assert s.units == \"SI\"\n assert s.cv.units == \"kilojoule / kelvin / kilogram\"\n assert s.cp.units == \"kilojoule / kelvin / kilogram\"\n assert s.s.units == \"kilojoule / kelvin / kilogram\"\n assert s.h.units == \"kilojoule / kilogram\"\n assert s.T.units == \"degree_Celsius\"\n assert s.u.units == \"kilojoule / kilogram\"\n assert s.v.units == \"meter ** 3 / kilogram\"\n assert s.p.units == \"bar\"","def _parse_units(self, model, comp, node):\n node = dom_child(node, 'unitDefinition')\n while node:\n name = node.getAttribute('id')\n self.log('Parsing unit definition for \"' + name + '\".')\n unit = myokit.units.dimensionless\n node2 = dom_child(node, 'listOfUnits')\n node2 = dom_child(node2, 'unit')\n while node2:\n kind = str(node2.getAttribute('kind')).strip()\n u2 = self._convert_unit(kind)\n if node2.hasAttribute('multiplier'):\n m = float(node2.getAttribute('multiplier'))\n else:\n m = 1.0\n if node2.hasAttribute('scale'):\n m *= 10 ** float(node2.getAttribute('scale'))\n u2 *= m\n if node2.hasAttribute('exponent'):\n u2 **= float(node2.getAttribute('exponent'))\n unit *= u2\n node2 = dom_next(node2, 'unit')\n self.units[name] = unit\n node = dom_next(node, 'unitDefinition')","def convert_units(data, units):\n # Build the dictionary of units conversions\n convert = {'m' : [1.0, 0., 'm'], \n 'meter' : [1.0, 0., 'm'], \n 'deg C' : [1.0, 273.15, 'K'], \n 'Celsius' : [1.0, 273.15, 'K'], \n 'K' : [1.0, 0., 'K'],\n 'db' : [1.e4, 101325., 'Pa'], \n 'Pa' : [1.0, 0., 'Pa'],\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \n 'S/m': [1.0, 0., 'S/m'],\n 'mS/m' : [1.e-3, 0., 'S/m'],\n 'psu': [1.0, 0., 'psu'], \n 'salinity': [1.0, 0., 'psu'], \n 'kg/m^3': [1.0, 0., 'kg/m^3'], \n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \n 'm/s': [1.0, 0., 'm/s'], \n 'mg/l': [1.e-3, 0., 'kg/m^3'],\n 'meter second-1' : [1.0, 0., 'm/s'],\n 'm.s-1' : [1.0, 0., 'm/s'],\n 'pH units' : [1.0, 0., 'pH units'],\n 'MPa' : [1.e6, 0., 'Pa'],\n '--' : [1.0, 0., '--'],\n 'mD' : [9.869233e-16, 0., 'm^2'],\n 'um' : [1.e-6, 0., 'm'],\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\n 'wt.%' : [10., 0., 'psu'],\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\n 'm^2' : [1., 0., 'm^2'],\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \n } \n \n # Make sure the data are a numpy array and the units are a list\n if isinstance(data, float) or isinstance(data, int):\n data = np.array([data])\n if isinstance(data, list):\n data = np.array(data)\n if isinstance(units, str) or isinstance(units, unicode):\n units = [units]\n if units == None:\n units = ['']\n \n # Make sure you can slice through the columns: must be two-dimensional\n sh = data.shape\n data = np.atleast_2d(data)\n \n # Allow conversion of a row of data if all of the same unit\n if len(units) == 1 and data.shape[1] > 1:\n data = data.transpose()\n \n # Create an emtpy array to hold the output\n out_data = np.zeros(data.shape)\n out_units = []\n \n # Convert the units\n for i in range(len(units)):\n try:\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\n convert[units[i]][1]\n out_units += [convert[units[i]][2]]\n except KeyError:\n print('Do not know how to convert %s to mks units' % units[i])\n print('Continuing without converting these units...')\n out_data[:,i] = data[:,i]\n out_units += units[i]\n \n # Return the converted data in the original shape\n out_data = np.reshape(out_data, sh, 'C')\n return (out_data, out_units)","def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\n return process_unit_input(value, units, convert=True, registry=registry).v","def useUnits():","def assign_unit(self):\n self.units = {}\n for unit in RADIAL_UNITS:\n if unit.REPR == \"2th_deg\":\n self.units[unit] = self.tth_deg\n elif unit.REPR == \"2th_rad\":\n self.units[unit] = self.tth_rad\n elif unit.REPR == \"q_nm^-1\":\n self.units[unit] = self.q_nm\n elif unit.REPR == \"q_A^-1\":\n self.units[unit] = self.q_A\n elif unit.REPR == \"r_mm\":\n self.units[unit] = self.r_mm\n else:\n logger.warning(\"Unit unknown to GUI %s\" % unit)","def convert_to(self, units: str) -> None:\n if self.units == units:\n return\n\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\n msg = f\"\"\"Not a valid unit conversion. Valid destination units:\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\"\"\"\n raise ValueError(msg)\n\n if self.units == \"celsius\" and units == \"fahrenheit\":\n self._celsius_to_fahrenheit()\n elif self.units == \"m/s\" and units == \"km/h\":\n self._mps_to_kph()\n elif self.units == \"m/s\" and units == \"mph\":\n self._mps_to_mph()\n else:\n raise ValueError(\"Not a valid unit conversion.\")","def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)","def convert(obj, unit, axis):\r\n return obj","def getUnstructured_50_233_0083_Units(filename):\n doc = Document(filename)\n \n \n units=[]\n # iterate over all paragraphs to get text units\n for para in doc.paragraphs:\n paragraph = para.text\n if len(paragraph.strip())>0:\n units.append({'unit':paragraph.strip()})\n\n \n \n return units","def parse_unit(unit_string):\n with warnings.catch_warnings():\n warnings.filterwarnings('ignore', module='astropy')\n try:\n unit = u.Unit(unit_string, parse_strict='raise')\n except ValueError:\n new_string = unit_string.replace('(cm-1)', 'kayser')\n log.debug(f'\\tValue Error, try {new_string}')\n unit = u.Unit(new_string,\n parse_strict='silent')\n log.debug(f'Parsed {unit_string} into {unit} ({type(unit)}).')\n return unit","def convert_units(data, hdr, conv_to = \"surf_br\"):\n \n data_unit = hdr[\"SIGUNIT\"]\n \n if \"Jy/pix\" in data_unit:\n # pixel size in rad\n px_x = abs(hdr[\"CDELT1\"])*2*np.pi/360\n px_y = abs(hdr[\"CDELT2\"])*2*np.pi/360\n \n #pixel size in arcsec\n \n px_x = abs(hdr[\"CDELT1\"])*3600\n px_y = abs(hdr[\"CDELT2\"])*3600\n conversion_factor = 1000/(px_x*px_y)\n \n unit_label = \"mJy/arcsec^2\"\n \n #in case we want to convert to units flux, we need to multiply by the size (in steradians) of a pixel.\n if conv_to == \"flux\":\n conversion_factor*=abs(hdr[\"CDELT1\"])*abs(hdr[\"CDELT2\"])*(2*np.pi/360)**2\n unit_label = \"mJy\"\n \n data *= conversion_factor\n hdr[\"SIGUNIT\"] = unit_label\n else:\n print(\"\\t[WARNING]\\t \"+data_unit+\" conversion not yet implemented. No conversion performed.\")\n \n return data, hdr","def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6","def convert(self):\n return _libsbml.SBMLUnitsConverter_convert(self)","def SBMLUnitsConverter_init():\n return _libsbml.SBMLUnitsConverter_init()","def UnitDefinition_convertToSI(*args):\n return _libsbml.UnitDefinition_convertToSI(*args)","def infer_original_units(self, dimensions):\n dimensions = units.Unit(dimensions)\n d = dimensions.dimensional_project(\n self._file_units_system + [\"a\", \"h\"])\n new_unit = reduce(lambda x, y: x * y, [\n a ** b for a, b in zip(self._file_units_system, d)])\n return new_unit","def convert(x, unit1, unit2):\r\n return conversions[unit1][unit2](x)","def convert_units(cube, units):\n try:\n cube.convert_units(units)\n except ValueError:\n if not _try_special_conversions(cube, units):\n raise\n\n return cube","def original_units(self):\n self.physical_units(distance=self.infer_original_units('km'),\n velocity=self.infer_original_units('km s^-1'),\n mass=self.infer_original_units('Msol'), persistent=False)","def buildUnits(self, obs, UnitName, Quantity):\n \n \"\"\"drones, overlords, zerglings, roaches, hydralisks, corrupters, queen(may need own function)\"\"\" \n actions.FUNCTIONS.select_larva(\"select\")\n if (UnitName == \"drone\"):\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\n return actions.FUNCTIONS.Train_Drone_quick(\"now\")\n if (UnitName == \"overlord\"):\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\n return actions.FUNCTIONS.Train_Overlord_quick(\"now\")\n if (UnitName == \"zergling\"):\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\n return actions.FUNCTIONS.Train_Zergling_quick(\"now\")\n if (UnitName == \"Roach\"):\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\n return actions.FUNCTIONS.Train_Roach_quick(\"now\")\n if (UnitName == \"hydralisks\"):\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\n return actions.FUNCTIONS.Train_Hydralisk_quick(\"now\")\n if (UnitName == \"corruptor\"):\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\n return actions.FUNCTIONS.Train_Corruptor_quick(\"now\")\n \"\"\"UnitsForControlGroup: [#drone, #zergling, #roaches, #hydralisks]\"\"\"","def spice_unit_convert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result /= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result *= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\n result *= numeric(spice_unit_unconvert([part, \"1.0\"], restrict))\n return str(result)\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n else:\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n newvalue = numeric(valuet[1]) * 0.01\n return str(newvalue)\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def Unit_convertToSI(*args):\n return _libsbml.Unit_convertToSI(*args)","def convert_to_unit(self, data, unit):\n\n res = OrderedDict()\n\n # Loop over data and overwrite\n for ch in data:\n _idx = self.channels.index(ch)\n # Get data, scale and type of channel\n val, scale, _type = data[ch], self.daq_setup['devices']['adc']['ro_scales'][_idx], self.daq_setup['devices']['adc']['types'][_idx]\n # Adjust scale in case we're looking at SEM's sum signal; in this case current is multiplied by factor of 4\n scale *= 1 if _type != 'sem_sum' else 4\n\n res[ch] = val / 5.0 * scale * 1e-9 if unit == 'A' else val * 5.0 / 1e-9 / scale\n\n return res","def units(inventory):\n return inventory.reduce(convert.get_units)","def getUnitDefinition(self, *args):\n return _libsbml.Model_getUnitDefinition(self, *args)","def _parse_unit_expression(self, units) -> t.Optional[unyt.Unit]:\n if units is not None:\n units = unyt.Unit(units, registry=self.registry)\n return units","def normalize_units(data):\n for obj in data:\n obj['unit'] = normalize_units_function(obj.get('unit', ''))\n # for param in ds.get('parameters', {}).values():\n # if 'unit' in param:\n # param['unit'] = normalize_units_function(param['unit'])\n return data","def convert_F_units(F, lbda, in_unit='cgs', out_unit='si'):\n\n if in_unit == 'cgs':\n new_F = (F*1e23*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == 'cgsA':\n new_F = (F*1e27*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == 'si':\n new_F = (F*1e26*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == \"jy\":\n new_F=F\n else:\n msg = \"in_unit not recognized, try either 'cgs', 'si' or 'jy'.\"\n raise TypeError(msg) \n if out_unit == 'jy':\n return new_F\n elif out_unit == 'cgs':\n return new_F*1e-23*c.c.value*1e6/np.power(lbda,2)\n elif out_unit == 'si':\n return new_F*1e-26*c.c.value*1e6/np.power(lbda,2)\n else:\n msg = \"out_unit not recognized, try either 'cgs', 'si' or 'jy'.\"\n raise TypeError(msg)","def convert_nasa_unit_to_astropy(unit_str):\n\n print('Unit str: ' + repr(unit_str))\n if unit_str in ['days', 'hrs']:\n unit_str = unit_str[:-1]\n elif unit_str == 'decimal degrees':\n unit_str = 'degree'\n elif (\n unit_str in ['dex', 'Earth flux', 'sexagesimal']\n or\n unit_str.startswith('log10(')\n or\n unit_str.startswith('log(')\n ):\n return None\n elif unit_str == 'Solar mass':\n unit_str = 'solMass'\n elif unit_str == 'Solar radii':\n unit_str = 'solRad'\n elif unit_str.endswith(' mass'):\n unit_str = unit_str.split()[0].lower() + 'Mass'\n elif unit_str.endswith(' radii'):\n unit_str = unit_str.split()[0].lower() + 'Rad'\n elif unit_str.startswith('percent'):\n return 0.01\n\n print('Converted to: ' + repr(unit_str))\n\n return Unit(unit_str)","def get_unit(self, unit_id: str) -> Mapping[str, Any]:\n return self.__get_one_by_id(\"units\", \"unit_id\", unit_id)","def convertToSI(*args):\n return _libsbml.UnitDefinition_convertToSI(*args)","def get_unit_from_doc(doc):\n invalid_units = ['this', 'long', 'all', 'setup', 'given', 'a']\n try:\n usplit = doc.rsplit(' in ')\n if 'Value' in doc and 'converted to' in doc:\n unit = '{:}'.format(doc.rsplit('converted to ')[-1].rstrip('.'))\n elif len(usplit) < 2:\n unit = ''\n else:\n unit = '{:}'.format(usplit[-1])\n unit = unit.rstrip('.').rstrip(',').rsplit(' ')[0].rstrip('.').rstrip(',')\n \n if unit.endswith('(') or unit in invalid_units:\n unit = ''\n \n except:\n unit = ''\n return unit","def test_convert_same_unit():\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5","def convert_unit(size_in_bytes, unit):\n if unit == 'KB':\n return size_in_bytes/1024\n elif unit == 'MB':\n return size_in_bytes/(1024*1024)\n elif unit == 'GB':\n return size_in_bytes/(1024*1024*1024)\n else:\n return size_in_bytes","def convert_string_to_unit(s):\n \n if \":\" not in s:\n match = UNIT_RE.match(s)\n if match:\n s = \"%s:%s\"%match.groups()\n \n return Unit(s)","def describe_a_library_of_units_converters_that():\n def blows_smoke():\n assert True\n\n def can_convert_psi_to_kpa():\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\n\n # def can_convert_kpa_to_psi():\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\n\n # def can_convert_mpg_to_lp100k():\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\n\n # def can_convert_lp100k_to_mpg():\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg","def createUnit(self):\n return _libsbml.UnitDefinition_createUnit(self)","def test_unit_conversion(self):\n self.cube_uv_down.convert_units(\"kW m-2\")\n scale_factor = 1.0\n expected = np.full_like(\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\n )\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\n self.assertArrayEqual(result.data, expected)","def _get_units(self, q) -> unyt.Unit:\n try:\n units = q.units\n except AttributeError:\n units = unyt.dimensionless\n return unyt.Unit(units, registry=self.registry)","def get_converted_si_unit():\n units = request.args.get('units')\n response = ConvertUnit(units).convert()\n return jsonify(response)","def load_unitsm(self):\n self.unit_file = self.path+'units.m'\n self.unit_dic = self.load_m(self.unit_file) #actual reading routine\n self.psix=self.unit_dic['psi_x']\n self.eq_x_r = self.unit_dic['eq_x_r']\n self.eq_x_z = self.unit_dic['eq_x_z']\n self.eq_axis_r = self.unit_dic['eq_axis_r']\n self.eq_axis_z = self.unit_dic['eq_axis_z']\n self.eq_axis_b = self.unit_dic['eq_axis_b']\n self.sml_dt = self.unit_dic['sml_dt']\n self.sml_wedge_n = self.unit_dic['sml_wedge_n']\n self.diag_1d_period = self.unit_dic['diag_1d_period']","def make_lems_unit(newunit):\n strunit = _to_lems_unit(newunit)\n power = int(np.log10((mmetre**2).base))\n dimension = _determine_dimension(newunit)\n return lems.Unit(strunit, symbol=strunit, dimension=dimension, power=power)","def _to(\n value: Union[\"Value\", \"ValueArray\"], units: Union[Unit, str], inplace: bool\n) -> Any:\n if value.units == units:\n return value\n\n if value.units is None:\n raise RuntimeError(\"Cannot convert with units=None\")\n\n try:\n units = next(\n imp_unit\n for imp_unit in value.implemented_units\n if units.lower() in imp_unit.aliases\n )\n\n except StopIteration:\n raise TypeError(\n f\"No viable unit conversion from {value.units} -> {units}\"\n )\n\n if not (isinstance(value, Value) or isinstance(value, ValueArray)):\n raise ValueError(\n f\"Cannot convert {value} to new units. Must be one of\"\n f\" Value of ValueArray\"\n )\n\n if isinstance(value, Value) and inplace:\n raise ValueError(\n \"Cannot modify a value inplace as floats are immutable\"\n )\n\n # Convert to the base unit, then to the new units\n c = float(units.conversion / value.units.conversion)\n\n new_value = value if inplace else value.copy()\n new_value *= c\n new_value.units = units\n\n return None if inplace else new_value","def convert_flux(nu, flux, target_unit):\n\n curr_unit = flux.unit\n\n if curr_unit.is_equivalent(u.erg / u.s):\n flux = flux / sed.distance ** 2\n elif curr_unit.is_equivalent(u.Jy):\n flux = flux * nu\n elif not curr_unit.is_equivalent(u.erg / u.cm ** 2 / u.s):\n raise Exception(\"Don't know how to convert {0} to ergs/cm^2/s\" % (flux.unit))\n\n # Convert to requested unit\n\n if target_unit.is_equivalent(u.erg / u.s):\n flux = flux * sed.distance ** 2\n elif target_unit.is_equivalent(u.Jy):\n flux = flux / nu\n elif not target_unit.is_equivalent(u.erg / u.cm ** 2 / u.s):\n raise Exception(\"Don't know how to convert %s to %s\" % (curr_unit, unit_flux))\n\n return flux.to(target_unit)","def getUnit(self, *args):\n return _libsbml.UnitDefinition_getUnit(self, *args)","def convert_units(celsius_value, units):\n if units == 0:\n return celsius_value\n if units == 1:\n return celsius_value * 1.8 + 32\n return celsius_value + 273.15","def convert_units(array, in_units=\"None\"):\n if in_units == \"None\" or in_units is None:\n return array\n else:\n raise Exception(\"Unsupported unit for bispectrum descriptors.\")","def to(self, units):\n return _to(self, units, inplace=False)","def getUnstructured042_special_Units(filename):\n doc = Document(filename)\n units = list()\n # all interviews start with a header\n isHeader = True\n # iterate over all paragraphs to get text units\n for para in doc.paragraphs:\n paragraph = para.text\n \n # ensure paragraph is not just empty line\n hasText = paragraph.lstrip()\n # ensure it is not an empty line\n if hasText:\n\n \n units.append({'unit':paragraph})\n return units","def init():\n return _libsbml.SBMLUnitsConverter_init()","def _override_units_system(self):\n try:\n f = open(self.filename+\".units\")\n except OSError:\n return\n\n name_mapping = {'pos': 'distance', 'vel': 'velocity'}\n units_dict = {}\n\n for line in f:\n if (not line.startswith(\"#\")):\n if \":\" not in line:\n raise OSError(\"Unknown format for units file %r\"%(self.filename+\".units\"))\n else:\n t, u = list(map(str.strip,line.split(\":\")))\n t = name_mapping.get(t,t)\n units_dict[t] = u\n\n self.set_units_system(**units_dict)","def to_base_unit(val: float, unit: str = \"\") -> float:\n unit_scalar = UNITS.get(unit, None)\n if not unit_scalar:\n raise UnknownUnitError(f\"Unit '{unit}' is not supported\")\n\n return val * unit_scalar","def get_unit(shared, unit_name):\n if (shared.config.get_safe('data', 'use_units') != 'off'):\n unit_val, unit_str = shared.config.get_safe_literal('units', unit_name,\n default=(1.0, ''))\n if unit_str:\n unit_str = ' [' + unit_str + ']'\n else:\n unit_val = 1.0\n unit_str = ''\n \n return unit_val, unit_str","def from_unit(cls, pulp_unit):\n unit_as_dict = copy.copy(pulp_unit.unit_key)\n unit_as_dict.update(pulp_unit.metadata)\n return cls.from_dict(unit_as_dict)","def _get_units(self):\n #assert self.ser.isOpen()\n\n self.serial_connection.write('UNI' + self.CR + self.LF)\n acknowledgement = self.serial_connection.readline()\n self._check_acknowledgement(acknowledgement)\n\n self.serial_connection.write(self.ENQ)\n unit = self.MEASUREMENT_UNITS[self.serial_connection.readline().rstrip(self.LF).rstrip(self.CR)]\n\n self.serial_connection.write(self.CR + self.LF)\n\n return unit","def createUnit(self):\n return _libsbml.Model_createUnit(self)","def to(self, new_unit, **kwargs):\n new_unit = u.Unit(new_unit)\n return self * (self.unit.to(new_unit, **kwargs) * new_unit / self.unit)","def unit_string(value, units, prefu={'M', 'L', 'J', 'C', 'V', 'N', 'W', 'Pa'}):\r\n if units == unity or not value:\r\n return value, \"\", \"\"\r\n SIunits = list(units)\r\n derived = dict((pu, 0) for pu in prefu if sum(abs(t) for t in unitquant[pu].units) > 1)\r\n while derived:\r\n (improvement, d, sign) = try_all_derived(SIunits, derived)\r\n if improvement <= 0:\r\n break\r\n derived[d] += sign\r\n for i, used_in_derived in enumerate(unitquant[d].units):\r\n SIunits[i] -= used_in_derived * sign\r\n value /= unitquant[d].number ** sign\r\n allunits = dict([(x, derived[x]) for x in derived if derived[x]])\r\n DUS = [du for du in allunits if du in derived]\r\n for DU in DUS: # choose between atm and mmHg etc.\r\n choices = [pu for pu in derived if unitquant[pu].units == unitquant[DU].units]\r\n if not choices:\r\n break\r\n quality = [(abs(math_log10(abs(value) / (unitquant[c].number / unitquant[DU].number) ** allunits[DU]) - 1.0), c)\r\n for c in choices]\r\n best = min(quality)[1]\r\n if best != DU:\r\n allunits[best] = allunits[DU]\r\n value /= (unitquant[best].number / unitquant[DU].number) ** allunits[best]\r\n allunits[DU] = 0\r\n for i, SIU in enumerate(SIunit_symbols): # choose between m, cm, mm etc.\r\n if not SIunits[i]:\r\n continue\r\n choices = [pu for pu in prefu if (pu not in derived) and unitquant[pu].units[i]]\r\n if not choices:\r\n break\r\n quality = [(abs(math_log10(abs(value) / unitquant[c].number ** (SIunits[i] / unitquant[c].units[i])) - 1.0), c)\r\n for c in choices]\r\n best = min(quality)[1]\r\n allunits[best] = Fraction(SIunits[i], unitquant[best].units[i])\r\n if allunits[best].denominator == 1:\r\n allunits[best] = int(allunits[best])\r\n SIunits[i] = 0\r\n value /= unitquant[best].number ** allunits[best]\r\n for u, d in zip(SIunit_symbols, SIunits):\r\n if d:\r\n allunits[u] = d\r\n poslist = [(u, exp) for u, exp in allunits.items() if exp > 0]\r\n neglist = [(u, -exp) for u, exp in allunits.items() if exp < 0]\r\n return value, poslist, neglist","def unit(x,convert_to=\"px\",from_unit=\"px\"):\n assert convert_to in UNITS, \"Cannot convert to unknown unit: %s\" % convert_to\n assert from_unit in UNITS, \"Cannot from unknown unit: %s\" % from_unit\n return float(x)*UNITS[convert_to]/UNITS[from_unit]","def to_(self, units) -> None:\n _to(self, units, inplace=True)","def UnitDefinition_simplify(*args):\n return _libsbml.UnitDefinition_simplify(*args)","def convert(self, value, units, newunits):\n return value * self._units[units] / self._units[newunits]","def _getunits(x):\n if pb.units.has_units(x):\n \n units = x.units\n \n else:\n \n units = None\n \n return units","def _get_or_create_unit(self,\n unit_name_truncated: str,\n unit_name_full: str) -> Squonk2AgentRv:\n # Get existing Units for our Organisation\n org_uuid: str = self.__org_record.uuid\n as_rv: AsApiRv = AsApi.get_units(self.__org_owner_as_token, org_id=org_uuid)\n if not as_rv.success:\n msg: str = as_rv.msg['error']\n _LOGGER.error('Failed to get Units for Organisation \"%s\"', org_uuid)\n return Squonk2AgentRv(success=False, msg=msg)\n # Iterate through them, looking for ours...\n _LOGGER.info('Got %s Units for Organisation \"%s\"', len(as_rv.msg['units']), org_uuid)\n for unit in as_rv.msg['units']:\n if unit['name'] == unit_name_truncated:\n unit_uuid: str = unit['id']\n _LOGGER.info('...and one was ours (%s)', unit_uuid)\n return Squonk2AgentRv(success=True, msg=unit_uuid)\n\n # Not found, create it...\n _LOGGER.info('No exiting Unit, creating NEW Unit \"%s\" (for \"%s\")',\n unit_name_full,\n unit_name_truncated)\n as_rv = AsApi.create_unit(self.__org_owner_as_token,\n unit_name=unit_name_truncated,\n org_id=org_uuid,\n billing_day=self.__unit_billing_day)\n if not as_rv.success:\n msg = as_rv.msg['error']\n _LOGGER.error('Failed to create Unit \"%s\" (for \"%s\")',\n unit_name_full, unit_name_truncated)\n return Squonk2AgentRv(success=False, msg=msg)\n\n unit_uuid = as_rv.msg['id']\n _LOGGER.info('Created NEW Unit \"%s\"', unit_uuid)\n return Squonk2AgentRv(success=True, msg=unit_uuid)","def to(self, units) -> Any:\n return _to(self, units, inplace=False)","def convert(value, unit, axis):\n converted_value = value\n if isinstance(unit, str) or isinstance(unit, Unit):\n unit = (unit,)\n if isinstance(value, (unyt_array, unyt_quantity)):\n converted_value = value.to(*unit)\n else:\n value_type = type(value)\n converted_value = []\n for obj in value:\n converted_value.append(obj.to(*unit))\n converted_value = value_type(converted_value)\n return converted_value","def setup_md_units(md_base_units: Dict[str, Union[str, float]]):\n # Initialize basic unit system\n md_base_units = {u: _parse_unit(md_base_units[u]) for u in md_base_units}\n\n # Set up unit dictionary\n units = Units(md_base_units)\n\n # Derived units (MD internal -> ASE internal)\n units[\"time\"] = units[\"length\"] * np.sqrt(units[\"mass\"] / units[\"energy\"])\n units[\"force\"] = units[\"energy\"] / units[\"length\"]\n units[\"stress\"] = units[\"energy\"] / units[\"length\"] ** 3\n units[\"pressure\"] = units[\"stress\"]\n\n # Conversion of length units\n units[\"A\"] = aseunits.Angstrom / units[\"length\"]\n units[\"Ang\"] = units[\"A\"]\n units[\"Angs\"] = units[\"A\"]\n units[\"Angstrom\"] = units[\"A\"]\n units[\"nm\"] = aseunits.nm / units[\"length\"]\n units[\"a0\"] = aseunits.Bohr / units[\"length\"]\n units[\"Bohr\"] = units[\"a0\"]\n\n # Conversion of energy units\n units[\"kcal\"] = aseunits.kcal / units[\"energy\"]\n units[\"kJ\"] = aseunits.kJ / units[\"energy\"]\n units[\"eV\"] = aseunits.eV / units[\"energy\"]\n units[\"Hartree\"] = aseunits.Hartree / units[\"energy\"]\n units[\"Ha\"] = units[\"Hartree\"]\n\n # Time units\n units[\"fs\"] = aseunits.fs / units[\"time\"]\n units[\"s\"] = aseunits.s / units[\"time\"]\n units[\"aut\"] = aseunits._aut * aseunits.s / units[\"time\"]\n\n # Pressure units\n units[\"Pascal\"] = aseunits.Pascal / units[\"pressure\"]\n units[\"bar\"] = 1e5 * units[\"Pascal\"]\n\n # Mol\n units[\"mol\"] = aseunits.mol\n\n # Mass\n units[\"Dalton\"] = 1.0 / units[\"mass\"]\n units[\"amu\"] = aseunits._amu / units[\"mass\"]\n\n # Charge distributions\n units[\"Debye\"] = aseunits.Debye / (units[\"charge\"] * units[\"length\"])\n units[\"C\"] = aseunits.C / units[\"charge\"]\n\n # Constants (internal frame)\n units[\"kB\"] = aseunits.kB / units[\"energy\"] # Always uses Kelvin\n units[\"hbar\"] = (\n aseunits._hbar * (aseunits.J * aseunits.s) / (units[\"energy\"] * units[\"time\"])\n ) # hbar is given in J*s by ASE\n units[\"ke\"] = (\n units[\"a0\"] * units[\"Ha\"] / units[\"charge\"] ** 2\n ) # Coulomb constant is 1 in atomic units\n\n # For spectra\n units[\"hbar2icm\"] = units[\"hbar\"] * 100.0 * aseunits._c * aseunits._aut\n\n return units","def _replace_units(original_units, values_by_name):\n q = 1\n for arg_name, exponent in original_units.items():\n q = q * values_by_name[arg_name] ** exponent\n\n return getattr(q, \"_units\", UnitsContainer({}))","def convert_from_to(from_unit, to_unit, quantity):\n if not is_valid_unit(from_unit):\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\n if not is_valid_unit(to_unit):\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]","def convert(self):\n return _libsbml.SBMLInferUnitsConverter_convert(self)","def to_unit_validator(compatible_units):\n def _to_unit_validator(quantity_str):\n return process_unit_bearing_str(quantity_str, compatible_units)\n return _to_unit_validator","def convertUnits(self, varname, arr):\n if varname == \"SPDQ\" or varname == \"PHQ\":\n return arr*2.5e6/1000.\n return arr","def _get_unit_factor(self, unit: str) -> np.ndarray:\n\n unit_factors = {\n 'vx': np.array((1, 1, 1)),\n 'nm': np.array(self.parameters.scale),\n 'um': np.array(self.parameters.scale)/1000\n }\n assert unit in unit_factors.keys(), 'Invalid unit'\n unit_factor = unit_factors[unit]\n\n return unit_factor","def create_unit(self, unit_type):\n unit = None\n\n if unit_type == 'ElfRider':\n unit = ElfRider()\n elif unit_type == 'Knight':\n unit = Knight()\n elif unit_type == \"DwarfFighter\":\n unit = DwarfFighter()\n elif unit_type == 'OrcRider':\n unit = OrcRider()\n elif unit_type == 'Fairy':\n unit = Fairy()\n elif unit_type == 'Wizard':\n unit = Wizard()\n elif unit_type == 'ElfLord':\n unit = ElfLord()\n elif unit_type == 'OrcFighter':\n unit = OrcFighter()\n\n return unit","def unit_to_dict(self, unit):\n assert unit.type == 'A'\n\n path = self._get_assessment_path(unit)\n fs = self.app_context.fs\n if fs.isfile(path):\n content = fs.get(path)\n else:\n content = ''\n\n review_form_path = self._get_review_form_path(unit)\n if review_form_path and fs.isfile(review_form_path):\n review_form = fs.get(review_form_path)\n else:\n review_form = ''\n\n return {\n 'key': unit.unit_id,\n 'type': verify.UNIT_TYPE_NAMES[unit.type],\n 'title': unit.title,\n 'weight': str(unit.weight if hasattr(unit, 'weight') else 0),\n 'content': content,\n 'workflow_yaml': unit.workflow_yaml,\n 'review_form': review_form,\n 'is_draft': not unit.now_available,\n }","def _determine_unit(self, unit, units, abbrev_units):\n determined_unit = unit \n if unit in abbrev_units:\n determined_unit = abbrev_units[unit].lower()\n \n if determined_unit not in units:\n raise TableException('%s is an invalid unit' % unit)\n return determined_unit","def get_converted_unit(\n self,\n device_class: SensorDeviceClass | str | None,\n original_unit: str | None,\n ) -> str | None:\n return self._conversions.get((device_class, original_unit))","def unit_to_dict(self, unused_unit):\n raise Exception('Not implemented')","def unit_type(self) -> str:","def tranfer_unit(number):\n count = 0\n unit_name = \"\"\n if 2 ** 20 > number > 2 ** 10:\n unit_name = \"Kb\"\n count = 1\n elif 2 ** 30 > number > 2 ** 20:\n unit_name = \"Mb\"\n count = 2\n elif number > 2 ** 30:\n unit_name = \"Gb\"\n count = 3\n else:\n unit_name = \"b\"\n if count != 0:\n unit_number = round(number / ((2 ** 10) ** count), 2)\n else:\n unit_number = round(number, 2)\n unit_str = \"{num}{name}\".format(num=unit_number, name=unit_name)\n return unit_str","def spice_unit_unconvert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item / spice_unit_unconvert([parts[1], 1.0],\n\t\t\trestrict) for item in result)\n else:\n result /= spice_unit_unconvert([parts[1], 1.0], restrict)\n return result\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item * spice_unit_unconvert([parts[1], 1.0],\n\t\t\trestrict) for item in result)\n else:\n result *= spice_unit_unconvert([parts[1], 1.0], restrict)\n return result\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = spice_unit_unconvert([part, valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item * spice_unit_unconvert([part, 1.0],\n\t\t\trestrict) for item in result)\n else:\n result *= spice_unit_unconvert([part, 1.0], restrict)\n return result\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n if isinstance(valuet[1], list):\n return list(item / prefixtypes[prerec] for item in valuet[1])\n else:\n return valuet[1] / prefixtypes[prerec]\n else:\n if isinstance(valuet[1], list):\n return list(item / prefixtypes[prerec] for item in valuet[1])\n else:\n return valuet[1] / prefixtypes[prerec]\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n if isinstance(valuet[1], list):\n return list(item * 100 for item in valuet[1])\n else:\n return valuet[1] * 100\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def _parse_unit(unit: str) -> str:\n if unit == 'm_v':\n return 'm'\n return unit","def convert_units(self, time_units=None, len_units=None):\n in_time = self.time_units\n # Check new time units\n if time_units is None:\n time_units = in_time\n flag = _units.validate_units(time_units)\n if flag == -1:\n raise ValueError('Bad time units input {}'.format(time_units))\n # Check new length units\n in_len = self.len_units\n if len_units is None:\n len_units = in_len\n flag = _units.validate_units(len_units)\n if flag == -1:\n raise ValueError('Bad length units input {}'.format(len_units))\n # Convert parameters units\n for key, value in self.parameters.items():\n if type(value) in [int, float]:\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\n # Convert drawdown data\n self.drawdown.convert_units(time_units, len_units)\n # Convert associate data units\n for i in range(self.data_count()):\n if self.data[i].dtype == 1: # drawdown units\n data_units = len_units\n elif self.data[i].dtype == 2: # first derivative units\n data_units = len_units + \"/\" + time_units\n elif self.data[i].dtype == 3: # second derivative units\n data_units = len_units + \"/\" + time_units + \"2\"\n self.data[i].convert_units(time_units, data_units)\n self.len_units = len_units\n self.time_units = time_units\n # End Function"],"string":"[\n \"def _convert_unit(self, unit):\\n if unit in self.units:\\n return self.units[unit]\\n elif unit in unit_map:\\n return unit_map[unit]\\n else:\\n raise SBMLError('Unit not recognized: ' + str(unit))\",\n \"def _get_units_object(self, units):\\n if isinstance(units, cellml_units):\\n # We're done\\n pass\\n else:\\n units = amara_parse_cellml(unicode(units))\\n assert isinstance(units, cellml_units)\\n return units\",\n \"def fits_to_units(unit_str):\\n unit_lookup = {\\n 'meters': 'm',\\n 'meter': 'm',\\n 'degrees': 'deg',\\n 'degree': 'deg',\\n 'hz': 'Hz',\\n 'hertz': 'Hz',\\n 'second': 's',\\n 'sec': 's',\\n 'secs': 's',\\n 'days': 'd',\\n 'day': 'd',\\n 'steradians': 'sr',\\n 'steradian': 'sr',\\n 'radians': 'rad',\\n 'radian': 'rad',\\n 'jy': 'Jy',\\n 'au': 'AU',\\n }\\n\\n try:\\n new_units = \\\"\\\"\\n\\n if unit_str is None:\\n unit_str = ''\\n unit_str = unit_str.lower()\\n unit_list = unit_str.split(\\\"/\\\")\\n\\n for uu in unit_list:\\n if uu.endswith(\\\"s\\\") and len(uu) > 1:\\n uu = uu[:-1]\\n corrected_unit = unit_lookup.get(uu, uu)\\n new_units += corrected_unit\\n new_units += \\\" / \\\"\\n new_units = new_units[:-3]\\n unit = Unit(new_units)\\n return unit\\n\\n except ValueError:\\n warnings.warn(\\\"Unknown unit: %s\\\" % new_units, UnitWarning)\\n return UnrecognizedUnit(unit_str)\",\n \"def resolve_units(obj, _):\\n return obj.units.decode()\",\n \"def convert_units(unt, origunits):\\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\\n units = origunits\\n convf = 1\\n else:\\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'met':\\n units = 'feet'\\n convf = 3.2808399\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'met' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'fee':\\n units = 'meters'\\n convf = 0.3048\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'kno':\\n units = 'meters/sec'\\n convf = 0.51444444\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'm/s':\\n units = 'knots'\\n convf = 1.9438445\\n else:\\n units = origunits\\n convf = 1\\n else:\\n error('Unknown units')\\n #\\n return units, convf\",\n \"def units_to_fits(unit):\\n if unit is None:\\n unit = Unit('')\\n return unit.to_string(\\\"fits\\\").upper()\",\n \"def parse_unit(self, unitelem) -> Unit:\\n u = Unit()\\n\\n u.unitid = unitelem.attrib['id'].strip()\\n div = unitelem.find('{*}divide')\\n if div is not None:\\n nom = div.find('{*}unitNumerator').find('{*}measure')\\n denom = div.find('{*}unitDenominator').find('{*}measure')\\n u.nom = re.sub('.*:', '', nom.text).lower()\\n u.denom = re.sub('.*:', '', denom.text).lower()\\n else:\\n m = unitelem.find('{*}measure')\\n u.nom = re.sub('.*:', '', m.text).lower()\\n\\n return u\",\n \"def unit2internal(src_unit: Union[str, float]):\\n return _parse_unit(src_unit, conversion_factor=_conversion_factor_internal)\",\n \"def convertUnit(*args, fromUnit: AnyStr=\\\"\\\", toUnit: AnyStr=\\\"\\\", **kwargs)->float:\\n pass\",\n \"def to_unit(self, unit):\\n unit = _find_unit(unit)\\n self.value = _convert_value(self.value, self.unit, unit)\\n self.unit = unit\",\n \"def convert_units(self, units):\\n self.unit_array = self.unit_array.to(units)\",\n \"def _to_lems_unit(unit):\\n if type(unit) == str:\\n strunit = unit\\n else:\\n strunit = unit.in_best_unit()\\n strunit = strunit[3:] # here we substract '1. '\\n strunit = strunit.replace('^', '') # in LEMS there is no ^\\n return strunit\",\n \"def test_convert_compatible_units(self):\\n result = convert_units(self.arr, 'degC')\\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\\n expected_units = cf_units.Unit('degC')\\n self.assertEquals(result.units, expected_units)\\n self.assertArrayEqual(result.data, expected_data)\",\n \"def load_unit(self, unit_id):\",\n \"def _fix_units(cube, definition):\\n\\n if cube.var_name != 'pr':\\n cube.convert_units(definition.units)\",\n \"def unit(variable, unit):\\n try:\\n return myokit.Unit.convert(1, variable.unit(), unit)\\n except myokit.IncompatibleUnitError:\\n raise myokit.IncompatibleModelError(\\n variable.model().name(),\\n 'Incompatible units: ' + str(variable.unit()) + ' and '\\n + str(unit) + '.')\",\n \"def test_change_units(self):\\n s = State(\\\"water\\\", T=Q_(100, \\\"degC\\\"), p=Q_(1.0, \\\"atm\\\"), units=\\\"EE\\\")\\n assert s.units == \\\"EE\\\"\\n s.units = \\\"SI\\\"\\n assert s.units == \\\"SI\\\"\\n assert s.cv.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.cp.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.s.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.h.units == \\\"kilojoule / kilogram\\\"\\n assert s.T.units == \\\"degree_Celsius\\\"\\n assert s.u.units == \\\"kilojoule / kilogram\\\"\\n assert s.v.units == \\\"meter ** 3 / kilogram\\\"\\n assert s.p.units == \\\"bar\\\"\",\n \"def _parse_units(self, model, comp, node):\\n node = dom_child(node, 'unitDefinition')\\n while node:\\n name = node.getAttribute('id')\\n self.log('Parsing unit definition for \\\"' + name + '\\\".')\\n unit = myokit.units.dimensionless\\n node2 = dom_child(node, 'listOfUnits')\\n node2 = dom_child(node2, 'unit')\\n while node2:\\n kind = str(node2.getAttribute('kind')).strip()\\n u2 = self._convert_unit(kind)\\n if node2.hasAttribute('multiplier'):\\n m = float(node2.getAttribute('multiplier'))\\n else:\\n m = 1.0\\n if node2.hasAttribute('scale'):\\n m *= 10 ** float(node2.getAttribute('scale'))\\n u2 *= m\\n if node2.hasAttribute('exponent'):\\n u2 **= float(node2.getAttribute('exponent'))\\n unit *= u2\\n node2 = dom_next(node2, 'unit')\\n self.units[name] = unit\\n node = dom_next(node, 'unitDefinition')\",\n \"def convert_units(data, units):\\n # Build the dictionary of units conversions\\n convert = {'m' : [1.0, 0., 'm'], \\n 'meter' : [1.0, 0., 'm'], \\n 'deg C' : [1.0, 273.15, 'K'], \\n 'Celsius' : [1.0, 273.15, 'K'], \\n 'K' : [1.0, 0., 'K'],\\n 'db' : [1.e4, 101325., 'Pa'], \\n 'Pa' : [1.0, 0., 'Pa'],\\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \\n 'S/m': [1.0, 0., 'S/m'],\\n 'mS/m' : [1.e-3, 0., 'S/m'],\\n 'psu': [1.0, 0., 'psu'], \\n 'salinity': [1.0, 0., 'psu'], \\n 'kg/m^3': [1.0, 0., 'kg/m^3'], \\n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \\n 'm/s': [1.0, 0., 'm/s'], \\n 'mg/l': [1.e-3, 0., 'kg/m^3'],\\n 'meter second-1' : [1.0, 0., 'm/s'],\\n 'm.s-1' : [1.0, 0., 'm/s'],\\n 'pH units' : [1.0, 0., 'pH units'],\\n 'MPa' : [1.e6, 0., 'Pa'],\\n '--' : [1.0, 0., '--'],\\n 'mD' : [9.869233e-16, 0., 'm^2'],\\n 'um' : [1.e-6, 0., 'm'],\\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\\n 'wt.%' : [10., 0., 'psu'],\\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\\n 'm^2' : [1., 0., 'm^2'],\\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \\n } \\n \\n # Make sure the data are a numpy array and the units are a list\\n if isinstance(data, float) or isinstance(data, int):\\n data = np.array([data])\\n if isinstance(data, list):\\n data = np.array(data)\\n if isinstance(units, str) or isinstance(units, unicode):\\n units = [units]\\n if units == None:\\n units = ['']\\n \\n # Make sure you can slice through the columns: must be two-dimensional\\n sh = data.shape\\n data = np.atleast_2d(data)\\n \\n # Allow conversion of a row of data if all of the same unit\\n if len(units) == 1 and data.shape[1] > 1:\\n data = data.transpose()\\n \\n # Create an emtpy array to hold the output\\n out_data = np.zeros(data.shape)\\n out_units = []\\n \\n # Convert the units\\n for i in range(len(units)):\\n try:\\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\\\\n convert[units[i]][1]\\n out_units += [convert[units[i]][2]]\\n except KeyError:\\n print('Do not know how to convert %s to mks units' % units[i])\\n print('Continuing without converting these units...')\\n out_data[:,i] = data[:,i]\\n out_units += units[i]\\n \\n # Return the converted data in the original shape\\n out_data = np.reshape(out_data, sh, 'C')\\n return (out_data, out_units)\",\n \"def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\\n return process_unit_input(value, units, convert=True, registry=registry).v\",\n \"def useUnits():\",\n \"def assign_unit(self):\\n self.units = {}\\n for unit in RADIAL_UNITS:\\n if unit.REPR == \\\"2th_deg\\\":\\n self.units[unit] = self.tth_deg\\n elif unit.REPR == \\\"2th_rad\\\":\\n self.units[unit] = self.tth_rad\\n elif unit.REPR == \\\"q_nm^-1\\\":\\n self.units[unit] = self.q_nm\\n elif unit.REPR == \\\"q_A^-1\\\":\\n self.units[unit] = self.q_A\\n elif unit.REPR == \\\"r_mm\\\":\\n self.units[unit] = self.r_mm\\n else:\\n logger.warning(\\\"Unit unknown to GUI %s\\\" % unit)\",\n \"def convert_to(self, units: str) -> None:\\n if self.units == units:\\n return\\n\\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\\n msg = f\\\"\\\"\\\"Not a valid unit conversion. Valid destination units:\\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\\\"\\\"\\\"\\n raise ValueError(msg)\\n\\n if self.units == \\\"celsius\\\" and units == \\\"fahrenheit\\\":\\n self._celsius_to_fahrenheit()\\n elif self.units == \\\"m/s\\\" and units == \\\"km/h\\\":\\n self._mps_to_kph()\\n elif self.units == \\\"m/s\\\" and units == \\\"mph\\\":\\n self._mps_to_mph()\\n else:\\n raise ValueError(\\\"Not a valid unit conversion.\\\")\",\n \"def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)\",\n \"def convert(obj, unit, axis):\\r\\n return obj\",\n \"def getUnstructured_50_233_0083_Units(filename):\\n doc = Document(filename)\\n \\n \\n units=[]\\n # iterate over all paragraphs to get text units\\n for para in doc.paragraphs:\\n paragraph = para.text\\n if len(paragraph.strip())>0:\\n units.append({'unit':paragraph.strip()})\\n\\n \\n \\n return units\",\n \"def parse_unit(unit_string):\\n with warnings.catch_warnings():\\n warnings.filterwarnings('ignore', module='astropy')\\n try:\\n unit = u.Unit(unit_string, parse_strict='raise')\\n except ValueError:\\n new_string = unit_string.replace('(cm-1)', 'kayser')\\n log.debug(f'\\\\tValue Error, try {new_string}')\\n unit = u.Unit(new_string,\\n parse_strict='silent')\\n log.debug(f'Parsed {unit_string} into {unit} ({type(unit)}).')\\n return unit\",\n \"def convert_units(data, hdr, conv_to = \\\"surf_br\\\"):\\n \\n data_unit = hdr[\\\"SIGUNIT\\\"]\\n \\n if \\\"Jy/pix\\\" in data_unit:\\n # pixel size in rad\\n px_x = abs(hdr[\\\"CDELT1\\\"])*2*np.pi/360\\n px_y = abs(hdr[\\\"CDELT2\\\"])*2*np.pi/360\\n \\n #pixel size in arcsec\\n \\n px_x = abs(hdr[\\\"CDELT1\\\"])*3600\\n px_y = abs(hdr[\\\"CDELT2\\\"])*3600\\n conversion_factor = 1000/(px_x*px_y)\\n \\n unit_label = \\\"mJy/arcsec^2\\\"\\n \\n #in case we want to convert to units flux, we need to multiply by the size (in steradians) of a pixel.\\n if conv_to == \\\"flux\\\":\\n conversion_factor*=abs(hdr[\\\"CDELT1\\\"])*abs(hdr[\\\"CDELT2\\\"])*(2*np.pi/360)**2\\n unit_label = \\\"mJy\\\"\\n \\n data *= conversion_factor\\n hdr[\\\"SIGUNIT\\\"] = unit_label\\n else:\\n print(\\\"\\\\t[WARNING]\\\\t \\\"+data_unit+\\\" conversion not yet implemented. No conversion performed.\\\")\\n \\n return data, hdr\",\n \"def convert_units(self):\\n for prod in (\\\"ier\\\", \\\"ier_inc_rain\\\"):\\n self.data[prod].data[:] /= 1e6\",\n \"def convert(self):\\n return _libsbml.SBMLUnitsConverter_convert(self)\",\n \"def SBMLUnitsConverter_init():\\n return _libsbml.SBMLUnitsConverter_init()\",\n \"def UnitDefinition_convertToSI(*args):\\n return _libsbml.UnitDefinition_convertToSI(*args)\",\n \"def infer_original_units(self, dimensions):\\n dimensions = units.Unit(dimensions)\\n d = dimensions.dimensional_project(\\n self._file_units_system + [\\\"a\\\", \\\"h\\\"])\\n new_unit = reduce(lambda x, y: x * y, [\\n a ** b for a, b in zip(self._file_units_system, d)])\\n return new_unit\",\n \"def convert(x, unit1, unit2):\\r\\n return conversions[unit1][unit2](x)\",\n \"def convert_units(cube, units):\\n try:\\n cube.convert_units(units)\\n except ValueError:\\n if not _try_special_conversions(cube, units):\\n raise\\n\\n return cube\",\n \"def original_units(self):\\n self.physical_units(distance=self.infer_original_units('km'),\\n velocity=self.infer_original_units('km s^-1'),\\n mass=self.infer_original_units('Msol'), persistent=False)\",\n \"def buildUnits(self, obs, UnitName, Quantity):\\n \\n \\\"\\\"\\\"drones, overlords, zerglings, roaches, hydralisks, corrupters, queen(may need own function)\\\"\\\"\\\" \\n actions.FUNCTIONS.select_larva(\\\"select\\\")\\n if (UnitName == \\\"drone\\\"):\\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\\n return actions.FUNCTIONS.Train_Drone_quick(\\\"now\\\")\\n if (UnitName == \\\"overlord\\\"):\\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\\n return actions.FUNCTIONS.Train_Overlord_quick(\\\"now\\\")\\n if (UnitName == \\\"zergling\\\"):\\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\\n return actions.FUNCTIONS.Train_Zergling_quick(\\\"now\\\")\\n if (UnitName == \\\"Roach\\\"):\\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\\n return actions.FUNCTIONS.Train_Roach_quick(\\\"now\\\")\\n if (UnitName == \\\"hydralisks\\\"):\\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\\n return actions.FUNCTIONS.Train_Hydralisk_quick(\\\"now\\\")\\n if (UnitName == \\\"corruptor\\\"):\\n if self.can_do(obs, actions.FUNCTIONS.Train_Zergling_quick.id):\\n return actions.FUNCTIONS.Train_Corruptor_quick(\\\"now\\\")\\n \\\"\\\"\\\"UnitsForControlGroup: [#drone, #zergling, #roaches, #hydralisks]\\\"\\\"\\\"\",\n \"def spice_unit_convert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result /= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result *= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\\n result *= numeric(spice_unit_unconvert([part, \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n else:\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n newvalue = numeric(valuet[1]) * 0.01\\n return str(newvalue)\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def Unit_convertToSI(*args):\\n return _libsbml.Unit_convertToSI(*args)\",\n \"def convert_to_unit(self, data, unit):\\n\\n res = OrderedDict()\\n\\n # Loop over data and overwrite\\n for ch in data:\\n _idx = self.channels.index(ch)\\n # Get data, scale and type of channel\\n val, scale, _type = data[ch], self.daq_setup['devices']['adc']['ro_scales'][_idx], self.daq_setup['devices']['adc']['types'][_idx]\\n # Adjust scale in case we're looking at SEM's sum signal; in this case current is multiplied by factor of 4\\n scale *= 1 if _type != 'sem_sum' else 4\\n\\n res[ch] = val / 5.0 * scale * 1e-9 if unit == 'A' else val * 5.0 / 1e-9 / scale\\n\\n return res\",\n \"def units(inventory):\\n return inventory.reduce(convert.get_units)\",\n \"def getUnitDefinition(self, *args):\\n return _libsbml.Model_getUnitDefinition(self, *args)\",\n \"def _parse_unit_expression(self, units) -> t.Optional[unyt.Unit]:\\n if units is not None:\\n units = unyt.Unit(units, registry=self.registry)\\n return units\",\n \"def normalize_units(data):\\n for obj in data:\\n obj['unit'] = normalize_units_function(obj.get('unit', ''))\\n # for param in ds.get('parameters', {}).values():\\n # if 'unit' in param:\\n # param['unit'] = normalize_units_function(param['unit'])\\n return data\",\n \"def convert_F_units(F, lbda, in_unit='cgs', out_unit='si'):\\n\\n if in_unit == 'cgs':\\n new_F = (F*1e23*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == 'cgsA':\\n new_F = (F*1e27*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == 'si':\\n new_F = (F*1e26*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == \\\"jy\\\":\\n new_F=F\\n else:\\n msg = \\\"in_unit not recognized, try either 'cgs', 'si' or 'jy'.\\\"\\n raise TypeError(msg) \\n if out_unit == 'jy':\\n return new_F\\n elif out_unit == 'cgs':\\n return new_F*1e-23*c.c.value*1e6/np.power(lbda,2)\\n elif out_unit == 'si':\\n return new_F*1e-26*c.c.value*1e6/np.power(lbda,2)\\n else:\\n msg = \\\"out_unit not recognized, try either 'cgs', 'si' or 'jy'.\\\"\\n raise TypeError(msg)\",\n \"def convert_nasa_unit_to_astropy(unit_str):\\n\\n print('Unit str: ' + repr(unit_str))\\n if unit_str in ['days', 'hrs']:\\n unit_str = unit_str[:-1]\\n elif unit_str == 'decimal degrees':\\n unit_str = 'degree'\\n elif (\\n unit_str in ['dex', 'Earth flux', 'sexagesimal']\\n or\\n unit_str.startswith('log10(')\\n or\\n unit_str.startswith('log(')\\n ):\\n return None\\n elif unit_str == 'Solar mass':\\n unit_str = 'solMass'\\n elif unit_str == 'Solar radii':\\n unit_str = 'solRad'\\n elif unit_str.endswith(' mass'):\\n unit_str = unit_str.split()[0].lower() + 'Mass'\\n elif unit_str.endswith(' radii'):\\n unit_str = unit_str.split()[0].lower() + 'Rad'\\n elif unit_str.startswith('percent'):\\n return 0.01\\n\\n print('Converted to: ' + repr(unit_str))\\n\\n return Unit(unit_str)\",\n \"def get_unit(self, unit_id: str) -> Mapping[str, Any]:\\n return self.__get_one_by_id(\\\"units\\\", \\\"unit_id\\\", unit_id)\",\n \"def convertToSI(*args):\\n return _libsbml.UnitDefinition_convertToSI(*args)\",\n \"def get_unit_from_doc(doc):\\n invalid_units = ['this', 'long', 'all', 'setup', 'given', 'a']\\n try:\\n usplit = doc.rsplit(' in ')\\n if 'Value' in doc and 'converted to' in doc:\\n unit = '{:}'.format(doc.rsplit('converted to ')[-1].rstrip('.'))\\n elif len(usplit) < 2:\\n unit = ''\\n else:\\n unit = '{:}'.format(usplit[-1])\\n unit = unit.rstrip('.').rstrip(',').rsplit(' ')[0].rstrip('.').rstrip(',')\\n \\n if unit.endswith('(') or unit in invalid_units:\\n unit = ''\\n \\n except:\\n unit = ''\\n return unit\",\n \"def test_convert_same_unit():\\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5\",\n \"def convert_unit(size_in_bytes, unit):\\n if unit == 'KB':\\n return size_in_bytes/1024\\n elif unit == 'MB':\\n return size_in_bytes/(1024*1024)\\n elif unit == 'GB':\\n return size_in_bytes/(1024*1024*1024)\\n else:\\n return size_in_bytes\",\n \"def convert_string_to_unit(s):\\n \\n if \\\":\\\" not in s:\\n match = UNIT_RE.match(s)\\n if match:\\n s = \\\"%s:%s\\\"%match.groups()\\n \\n return Unit(s)\",\n \"def describe_a_library_of_units_converters_that():\\n def blows_smoke():\\n assert True\\n\\n def can_convert_psi_to_kpa():\\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\\n\\n # def can_convert_kpa_to_psi():\\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\\n\\n # def can_convert_mpg_to_lp100k():\\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\\n\\n # def can_convert_lp100k_to_mpg():\\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg\",\n \"def createUnit(self):\\n return _libsbml.UnitDefinition_createUnit(self)\",\n \"def test_unit_conversion(self):\\n self.cube_uv_down.convert_units(\\\"kW m-2\\\")\\n scale_factor = 1.0\\n expected = np.full_like(\\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\\n )\\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\\n self.assertArrayEqual(result.data, expected)\",\n \"def _get_units(self, q) -> unyt.Unit:\\n try:\\n units = q.units\\n except AttributeError:\\n units = unyt.dimensionless\\n return unyt.Unit(units, registry=self.registry)\",\n \"def get_converted_si_unit():\\n units = request.args.get('units')\\n response = ConvertUnit(units).convert()\\n return jsonify(response)\",\n \"def load_unitsm(self):\\n self.unit_file = self.path+'units.m'\\n self.unit_dic = self.load_m(self.unit_file) #actual reading routine\\n self.psix=self.unit_dic['psi_x']\\n self.eq_x_r = self.unit_dic['eq_x_r']\\n self.eq_x_z = self.unit_dic['eq_x_z']\\n self.eq_axis_r = self.unit_dic['eq_axis_r']\\n self.eq_axis_z = self.unit_dic['eq_axis_z']\\n self.eq_axis_b = self.unit_dic['eq_axis_b']\\n self.sml_dt = self.unit_dic['sml_dt']\\n self.sml_wedge_n = self.unit_dic['sml_wedge_n']\\n self.diag_1d_period = self.unit_dic['diag_1d_period']\",\n \"def make_lems_unit(newunit):\\n strunit = _to_lems_unit(newunit)\\n power = int(np.log10((mmetre**2).base))\\n dimension = _determine_dimension(newunit)\\n return lems.Unit(strunit, symbol=strunit, dimension=dimension, power=power)\",\n \"def _to(\\n value: Union[\\\"Value\\\", \\\"ValueArray\\\"], units: Union[Unit, str], inplace: bool\\n) -> Any:\\n if value.units == units:\\n return value\\n\\n if value.units is None:\\n raise RuntimeError(\\\"Cannot convert with units=None\\\")\\n\\n try:\\n units = next(\\n imp_unit\\n for imp_unit in value.implemented_units\\n if units.lower() in imp_unit.aliases\\n )\\n\\n except StopIteration:\\n raise TypeError(\\n f\\\"No viable unit conversion from {value.units} -> {units}\\\"\\n )\\n\\n if not (isinstance(value, Value) or isinstance(value, ValueArray)):\\n raise ValueError(\\n f\\\"Cannot convert {value} to new units. Must be one of\\\"\\n f\\\" Value of ValueArray\\\"\\n )\\n\\n if isinstance(value, Value) and inplace:\\n raise ValueError(\\n \\\"Cannot modify a value inplace as floats are immutable\\\"\\n )\\n\\n # Convert to the base unit, then to the new units\\n c = float(units.conversion / value.units.conversion)\\n\\n new_value = value if inplace else value.copy()\\n new_value *= c\\n new_value.units = units\\n\\n return None if inplace else new_value\",\n \"def convert_flux(nu, flux, target_unit):\\n\\n curr_unit = flux.unit\\n\\n if curr_unit.is_equivalent(u.erg / u.s):\\n flux = flux / sed.distance ** 2\\n elif curr_unit.is_equivalent(u.Jy):\\n flux = flux * nu\\n elif not curr_unit.is_equivalent(u.erg / u.cm ** 2 / u.s):\\n raise Exception(\\\"Don't know how to convert {0} to ergs/cm^2/s\\\" % (flux.unit))\\n\\n # Convert to requested unit\\n\\n if target_unit.is_equivalent(u.erg / u.s):\\n flux = flux * sed.distance ** 2\\n elif target_unit.is_equivalent(u.Jy):\\n flux = flux / nu\\n elif not target_unit.is_equivalent(u.erg / u.cm ** 2 / u.s):\\n raise Exception(\\\"Don't know how to convert %s to %s\\\" % (curr_unit, unit_flux))\\n\\n return flux.to(target_unit)\",\n \"def getUnit(self, *args):\\n return _libsbml.UnitDefinition_getUnit(self, *args)\",\n \"def convert_units(celsius_value, units):\\n if units == 0:\\n return celsius_value\\n if units == 1:\\n return celsius_value * 1.8 + 32\\n return celsius_value + 273.15\",\n \"def convert_units(array, in_units=\\\"None\\\"):\\n if in_units == \\\"None\\\" or in_units is None:\\n return array\\n else:\\n raise Exception(\\\"Unsupported unit for bispectrum descriptors.\\\")\",\n \"def to(self, units):\\n return _to(self, units, inplace=False)\",\n \"def getUnstructured042_special_Units(filename):\\n doc = Document(filename)\\n units = list()\\n # all interviews start with a header\\n isHeader = True\\n # iterate over all paragraphs to get text units\\n for para in doc.paragraphs:\\n paragraph = para.text\\n \\n # ensure paragraph is not just empty line\\n hasText = paragraph.lstrip()\\n # ensure it is not an empty line\\n if hasText:\\n\\n \\n units.append({'unit':paragraph})\\n return units\",\n \"def init():\\n return _libsbml.SBMLUnitsConverter_init()\",\n \"def _override_units_system(self):\\n try:\\n f = open(self.filename+\\\".units\\\")\\n except OSError:\\n return\\n\\n name_mapping = {'pos': 'distance', 'vel': 'velocity'}\\n units_dict = {}\\n\\n for line in f:\\n if (not line.startswith(\\\"#\\\")):\\n if \\\":\\\" not in line:\\n raise OSError(\\\"Unknown format for units file %r\\\"%(self.filename+\\\".units\\\"))\\n else:\\n t, u = list(map(str.strip,line.split(\\\":\\\")))\\n t = name_mapping.get(t,t)\\n units_dict[t] = u\\n\\n self.set_units_system(**units_dict)\",\n \"def to_base_unit(val: float, unit: str = \\\"\\\") -> float:\\n unit_scalar = UNITS.get(unit, None)\\n if not unit_scalar:\\n raise UnknownUnitError(f\\\"Unit '{unit}' is not supported\\\")\\n\\n return val * unit_scalar\",\n \"def get_unit(shared, unit_name):\\n if (shared.config.get_safe('data', 'use_units') != 'off'):\\n unit_val, unit_str = shared.config.get_safe_literal('units', unit_name,\\n default=(1.0, ''))\\n if unit_str:\\n unit_str = ' [' + unit_str + ']'\\n else:\\n unit_val = 1.0\\n unit_str = ''\\n \\n return unit_val, unit_str\",\n \"def from_unit(cls, pulp_unit):\\n unit_as_dict = copy.copy(pulp_unit.unit_key)\\n unit_as_dict.update(pulp_unit.metadata)\\n return cls.from_dict(unit_as_dict)\",\n \"def _get_units(self):\\n #assert self.ser.isOpen()\\n\\n self.serial_connection.write('UNI' + self.CR + self.LF)\\n acknowledgement = self.serial_connection.readline()\\n self._check_acknowledgement(acknowledgement)\\n\\n self.serial_connection.write(self.ENQ)\\n unit = self.MEASUREMENT_UNITS[self.serial_connection.readline().rstrip(self.LF).rstrip(self.CR)]\\n\\n self.serial_connection.write(self.CR + self.LF)\\n\\n return unit\",\n \"def createUnit(self):\\n return _libsbml.Model_createUnit(self)\",\n \"def to(self, new_unit, **kwargs):\\n new_unit = u.Unit(new_unit)\\n return self * (self.unit.to(new_unit, **kwargs) * new_unit / self.unit)\",\n \"def unit_string(value, units, prefu={'M', 'L', 'J', 'C', 'V', 'N', 'W', 'Pa'}):\\r\\n if units == unity or not value:\\r\\n return value, \\\"\\\", \\\"\\\"\\r\\n SIunits = list(units)\\r\\n derived = dict((pu, 0) for pu in prefu if sum(abs(t) for t in unitquant[pu].units) > 1)\\r\\n while derived:\\r\\n (improvement, d, sign) = try_all_derived(SIunits, derived)\\r\\n if improvement <= 0:\\r\\n break\\r\\n derived[d] += sign\\r\\n for i, used_in_derived in enumerate(unitquant[d].units):\\r\\n SIunits[i] -= used_in_derived * sign\\r\\n value /= unitquant[d].number ** sign\\r\\n allunits = dict([(x, derived[x]) for x in derived if derived[x]])\\r\\n DUS = [du for du in allunits if du in derived]\\r\\n for DU in DUS: # choose between atm and mmHg etc.\\r\\n choices = [pu for pu in derived if unitquant[pu].units == unitquant[DU].units]\\r\\n if not choices:\\r\\n break\\r\\n quality = [(abs(math_log10(abs(value) / (unitquant[c].number / unitquant[DU].number) ** allunits[DU]) - 1.0), c)\\r\\n for c in choices]\\r\\n best = min(quality)[1]\\r\\n if best != DU:\\r\\n allunits[best] = allunits[DU]\\r\\n value /= (unitquant[best].number / unitquant[DU].number) ** allunits[best]\\r\\n allunits[DU] = 0\\r\\n for i, SIU in enumerate(SIunit_symbols): # choose between m, cm, mm etc.\\r\\n if not SIunits[i]:\\r\\n continue\\r\\n choices = [pu for pu in prefu if (pu not in derived) and unitquant[pu].units[i]]\\r\\n if not choices:\\r\\n break\\r\\n quality = [(abs(math_log10(abs(value) / unitquant[c].number ** (SIunits[i] / unitquant[c].units[i])) - 1.0), c)\\r\\n for c in choices]\\r\\n best = min(quality)[1]\\r\\n allunits[best] = Fraction(SIunits[i], unitquant[best].units[i])\\r\\n if allunits[best].denominator == 1:\\r\\n allunits[best] = int(allunits[best])\\r\\n SIunits[i] = 0\\r\\n value /= unitquant[best].number ** allunits[best]\\r\\n for u, d in zip(SIunit_symbols, SIunits):\\r\\n if d:\\r\\n allunits[u] = d\\r\\n poslist = [(u, exp) for u, exp in allunits.items() if exp > 0]\\r\\n neglist = [(u, -exp) for u, exp in allunits.items() if exp < 0]\\r\\n return value, poslist, neglist\",\n \"def unit(x,convert_to=\\\"px\\\",from_unit=\\\"px\\\"):\\n assert convert_to in UNITS, \\\"Cannot convert to unknown unit: %s\\\" % convert_to\\n assert from_unit in UNITS, \\\"Cannot from unknown unit: %s\\\" % from_unit\\n return float(x)*UNITS[convert_to]/UNITS[from_unit]\",\n \"def to_(self, units) -> None:\\n _to(self, units, inplace=True)\",\n \"def UnitDefinition_simplify(*args):\\n return _libsbml.UnitDefinition_simplify(*args)\",\n \"def convert(self, value, units, newunits):\\n return value * self._units[units] / self._units[newunits]\",\n \"def _getunits(x):\\n if pb.units.has_units(x):\\n \\n units = x.units\\n \\n else:\\n \\n units = None\\n \\n return units\",\n \"def _get_or_create_unit(self,\\n unit_name_truncated: str,\\n unit_name_full: str) -> Squonk2AgentRv:\\n # Get existing Units for our Organisation\\n org_uuid: str = self.__org_record.uuid\\n as_rv: AsApiRv = AsApi.get_units(self.__org_owner_as_token, org_id=org_uuid)\\n if not as_rv.success:\\n msg: str = as_rv.msg['error']\\n _LOGGER.error('Failed to get Units for Organisation \\\"%s\\\"', org_uuid)\\n return Squonk2AgentRv(success=False, msg=msg)\\n # Iterate through them, looking for ours...\\n _LOGGER.info('Got %s Units for Organisation \\\"%s\\\"', len(as_rv.msg['units']), org_uuid)\\n for unit in as_rv.msg['units']:\\n if unit['name'] == unit_name_truncated:\\n unit_uuid: str = unit['id']\\n _LOGGER.info('...and one was ours (%s)', unit_uuid)\\n return Squonk2AgentRv(success=True, msg=unit_uuid)\\n\\n # Not found, create it...\\n _LOGGER.info('No exiting Unit, creating NEW Unit \\\"%s\\\" (for \\\"%s\\\")',\\n unit_name_full,\\n unit_name_truncated)\\n as_rv = AsApi.create_unit(self.__org_owner_as_token,\\n unit_name=unit_name_truncated,\\n org_id=org_uuid,\\n billing_day=self.__unit_billing_day)\\n if not as_rv.success:\\n msg = as_rv.msg['error']\\n _LOGGER.error('Failed to create Unit \\\"%s\\\" (for \\\"%s\\\")',\\n unit_name_full, unit_name_truncated)\\n return Squonk2AgentRv(success=False, msg=msg)\\n\\n unit_uuid = as_rv.msg['id']\\n _LOGGER.info('Created NEW Unit \\\"%s\\\"', unit_uuid)\\n return Squonk2AgentRv(success=True, msg=unit_uuid)\",\n \"def to(self, units) -> Any:\\n return _to(self, units, inplace=False)\",\n \"def convert(value, unit, axis):\\n converted_value = value\\n if isinstance(unit, str) or isinstance(unit, Unit):\\n unit = (unit,)\\n if isinstance(value, (unyt_array, unyt_quantity)):\\n converted_value = value.to(*unit)\\n else:\\n value_type = type(value)\\n converted_value = []\\n for obj in value:\\n converted_value.append(obj.to(*unit))\\n converted_value = value_type(converted_value)\\n return converted_value\",\n \"def setup_md_units(md_base_units: Dict[str, Union[str, float]]):\\n # Initialize basic unit system\\n md_base_units = {u: _parse_unit(md_base_units[u]) for u in md_base_units}\\n\\n # Set up unit dictionary\\n units = Units(md_base_units)\\n\\n # Derived units (MD internal -> ASE internal)\\n units[\\\"time\\\"] = units[\\\"length\\\"] * np.sqrt(units[\\\"mass\\\"] / units[\\\"energy\\\"])\\n units[\\\"force\\\"] = units[\\\"energy\\\"] / units[\\\"length\\\"]\\n units[\\\"stress\\\"] = units[\\\"energy\\\"] / units[\\\"length\\\"] ** 3\\n units[\\\"pressure\\\"] = units[\\\"stress\\\"]\\n\\n # Conversion of length units\\n units[\\\"A\\\"] = aseunits.Angstrom / units[\\\"length\\\"]\\n units[\\\"Ang\\\"] = units[\\\"A\\\"]\\n units[\\\"Angs\\\"] = units[\\\"A\\\"]\\n units[\\\"Angstrom\\\"] = units[\\\"A\\\"]\\n units[\\\"nm\\\"] = aseunits.nm / units[\\\"length\\\"]\\n units[\\\"a0\\\"] = aseunits.Bohr / units[\\\"length\\\"]\\n units[\\\"Bohr\\\"] = units[\\\"a0\\\"]\\n\\n # Conversion of energy units\\n units[\\\"kcal\\\"] = aseunits.kcal / units[\\\"energy\\\"]\\n units[\\\"kJ\\\"] = aseunits.kJ / units[\\\"energy\\\"]\\n units[\\\"eV\\\"] = aseunits.eV / units[\\\"energy\\\"]\\n units[\\\"Hartree\\\"] = aseunits.Hartree / units[\\\"energy\\\"]\\n units[\\\"Ha\\\"] = units[\\\"Hartree\\\"]\\n\\n # Time units\\n units[\\\"fs\\\"] = aseunits.fs / units[\\\"time\\\"]\\n units[\\\"s\\\"] = aseunits.s / units[\\\"time\\\"]\\n units[\\\"aut\\\"] = aseunits._aut * aseunits.s / units[\\\"time\\\"]\\n\\n # Pressure units\\n units[\\\"Pascal\\\"] = aseunits.Pascal / units[\\\"pressure\\\"]\\n units[\\\"bar\\\"] = 1e5 * units[\\\"Pascal\\\"]\\n\\n # Mol\\n units[\\\"mol\\\"] = aseunits.mol\\n\\n # Mass\\n units[\\\"Dalton\\\"] = 1.0 / units[\\\"mass\\\"]\\n units[\\\"amu\\\"] = aseunits._amu / units[\\\"mass\\\"]\\n\\n # Charge distributions\\n units[\\\"Debye\\\"] = aseunits.Debye / (units[\\\"charge\\\"] * units[\\\"length\\\"])\\n units[\\\"C\\\"] = aseunits.C / units[\\\"charge\\\"]\\n\\n # Constants (internal frame)\\n units[\\\"kB\\\"] = aseunits.kB / units[\\\"energy\\\"] # Always uses Kelvin\\n units[\\\"hbar\\\"] = (\\n aseunits._hbar * (aseunits.J * aseunits.s) / (units[\\\"energy\\\"] * units[\\\"time\\\"])\\n ) # hbar is given in J*s by ASE\\n units[\\\"ke\\\"] = (\\n units[\\\"a0\\\"] * units[\\\"Ha\\\"] / units[\\\"charge\\\"] ** 2\\n ) # Coulomb constant is 1 in atomic units\\n\\n # For spectra\\n units[\\\"hbar2icm\\\"] = units[\\\"hbar\\\"] * 100.0 * aseunits._c * aseunits._aut\\n\\n return units\",\n \"def _replace_units(original_units, values_by_name):\\n q = 1\\n for arg_name, exponent in original_units.items():\\n q = q * values_by_name[arg_name] ** exponent\\n\\n return getattr(q, \\\"_units\\\", UnitsContainer({}))\",\n \"def convert_from_to(from_unit, to_unit, quantity):\\n if not is_valid_unit(from_unit):\\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\\n if not is_valid_unit(to_unit):\\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]\",\n \"def convert(self):\\n return _libsbml.SBMLInferUnitsConverter_convert(self)\",\n \"def to_unit_validator(compatible_units):\\n def _to_unit_validator(quantity_str):\\n return process_unit_bearing_str(quantity_str, compatible_units)\\n return _to_unit_validator\",\n \"def convertUnits(self, varname, arr):\\n if varname == \\\"SPDQ\\\" or varname == \\\"PHQ\\\":\\n return arr*2.5e6/1000.\\n return arr\",\n \"def _get_unit_factor(self, unit: str) -> np.ndarray:\\n\\n unit_factors = {\\n 'vx': np.array((1, 1, 1)),\\n 'nm': np.array(self.parameters.scale),\\n 'um': np.array(self.parameters.scale)/1000\\n }\\n assert unit in unit_factors.keys(), 'Invalid unit'\\n unit_factor = unit_factors[unit]\\n\\n return unit_factor\",\n \"def create_unit(self, unit_type):\\n unit = None\\n\\n if unit_type == 'ElfRider':\\n unit = ElfRider()\\n elif unit_type == 'Knight':\\n unit = Knight()\\n elif unit_type == \\\"DwarfFighter\\\":\\n unit = DwarfFighter()\\n elif unit_type == 'OrcRider':\\n unit = OrcRider()\\n elif unit_type == 'Fairy':\\n unit = Fairy()\\n elif unit_type == 'Wizard':\\n unit = Wizard()\\n elif unit_type == 'ElfLord':\\n unit = ElfLord()\\n elif unit_type == 'OrcFighter':\\n unit = OrcFighter()\\n\\n return unit\",\n \"def unit_to_dict(self, unit):\\n assert unit.type == 'A'\\n\\n path = self._get_assessment_path(unit)\\n fs = self.app_context.fs\\n if fs.isfile(path):\\n content = fs.get(path)\\n else:\\n content = ''\\n\\n review_form_path = self._get_review_form_path(unit)\\n if review_form_path and fs.isfile(review_form_path):\\n review_form = fs.get(review_form_path)\\n else:\\n review_form = ''\\n\\n return {\\n 'key': unit.unit_id,\\n 'type': verify.UNIT_TYPE_NAMES[unit.type],\\n 'title': unit.title,\\n 'weight': str(unit.weight if hasattr(unit, 'weight') else 0),\\n 'content': content,\\n 'workflow_yaml': unit.workflow_yaml,\\n 'review_form': review_form,\\n 'is_draft': not unit.now_available,\\n }\",\n \"def _determine_unit(self, unit, units, abbrev_units):\\n determined_unit = unit \\n if unit in abbrev_units:\\n determined_unit = abbrev_units[unit].lower()\\n \\n if determined_unit not in units:\\n raise TableException('%s is an invalid unit' % unit)\\n return determined_unit\",\n \"def get_converted_unit(\\n self,\\n device_class: SensorDeviceClass | str | None,\\n original_unit: str | None,\\n ) -> str | None:\\n return self._conversions.get((device_class, original_unit))\",\n \"def unit_to_dict(self, unused_unit):\\n raise Exception('Not implemented')\",\n \"def unit_type(self) -> str:\",\n \"def tranfer_unit(number):\\n count = 0\\n unit_name = \\\"\\\"\\n if 2 ** 20 > number > 2 ** 10:\\n unit_name = \\\"Kb\\\"\\n count = 1\\n elif 2 ** 30 > number > 2 ** 20:\\n unit_name = \\\"Mb\\\"\\n count = 2\\n elif number > 2 ** 30:\\n unit_name = \\\"Gb\\\"\\n count = 3\\n else:\\n unit_name = \\\"b\\\"\\n if count != 0:\\n unit_number = round(number / ((2 ** 10) ** count), 2)\\n else:\\n unit_number = round(number, 2)\\n unit_str = \\\"{num}{name}\\\".format(num=unit_number, name=unit_name)\\n return unit_str\",\n \"def spice_unit_unconvert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item / spice_unit_unconvert([parts[1], 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result /= spice_unit_unconvert([parts[1], 1.0], restrict)\\n return result\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item * spice_unit_unconvert([parts[1], 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result *= spice_unit_unconvert([parts[1], 1.0], restrict)\\n return result\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = spice_unit_unconvert([part, valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item * spice_unit_unconvert([part, 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result *= spice_unit_unconvert([part, 1.0], restrict)\\n return result\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n if isinstance(valuet[1], list):\\n return list(item / prefixtypes[prerec] for item in valuet[1])\\n else:\\n return valuet[1] / prefixtypes[prerec]\\n else:\\n if isinstance(valuet[1], list):\\n return list(item / prefixtypes[prerec] for item in valuet[1])\\n else:\\n return valuet[1] / prefixtypes[prerec]\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n if isinstance(valuet[1], list):\\n return list(item * 100 for item in valuet[1])\\n else:\\n return valuet[1] * 100\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def _parse_unit(unit: str) -> str:\\n if unit == 'm_v':\\n return 'm'\\n return unit\",\n \"def convert_units(self, time_units=None, len_units=None):\\n in_time = self.time_units\\n # Check new time units\\n if time_units is None:\\n time_units = in_time\\n flag = _units.validate_units(time_units)\\n if flag == -1:\\n raise ValueError('Bad time units input {}'.format(time_units))\\n # Check new length units\\n in_len = self.len_units\\n if len_units is None:\\n len_units = in_len\\n flag = _units.validate_units(len_units)\\n if flag == -1:\\n raise ValueError('Bad length units input {}'.format(len_units))\\n # Convert parameters units\\n for key, value in self.parameters.items():\\n if type(value) in [int, float]:\\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\\n # Convert drawdown data\\n self.drawdown.convert_units(time_units, len_units)\\n # Convert associate data units\\n for i in range(self.data_count()):\\n if self.data[i].dtype == 1: # drawdown units\\n data_units = len_units\\n elif self.data[i].dtype == 2: # first derivative units\\n data_units = len_units + \\\"/\\\" + time_units\\n elif self.data[i].dtype == 3: # second derivative units\\n data_units = len_units + \\\"/\\\" + time_units + \\\"2\\\"\\n self.data[i].convert_units(time_units, data_units)\\n self.len_units = len_units\\n self.time_units = time_units\\n # End Function\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73016477","0.6947638","0.69390184","0.69115627","0.69105035","0.6857282","0.6822706","0.6779308","0.66278255","0.6605075","0.6557178","0.65434927","0.6530906","0.6432699","0.6416121","0.6377947","0.6370534","0.6358671","0.63333696","0.63289326","0.63137287","0.62564003","0.6244648","0.6224863","0.62013537","0.61988425","0.6187764","0.61603814","0.61385304","0.6131805","0.6127906","0.60852015","0.6070042","0.60562074","0.6037569","0.60275775","0.6014558","0.6005777","0.59883803","0.5960326","0.5947174","0.59320635","0.5927931","0.59246546","0.591827","0.5918045","0.59104526","0.5899391","0.58970934","0.5890145","0.58890665","0.58765054","0.5874601","0.5865692","0.5864861","0.5863782","0.5859612","0.5852797","0.5850569","0.5848066","0.583693","0.58226365","0.58224344","0.5815077","0.579765","0.5793366","0.57921124","0.57745117","0.57732385","0.57703453","0.576477","0.5764315","0.57543075","0.5753728","0.5746822","0.57420933","0.5733583","0.5732684","0.57290894","0.5727964","0.5727313","0.5727299","0.5726123","0.5722092","0.5718592","0.57179624","0.57148004","0.5711548","0.57034266","0.5702801","0.57012343","0.5700788","0.5700273","0.56985605","0.56832385","0.5682147","0.56815153","0.5676475","0.5671381","0.56617546"],"string":"[\n \"0.73016477\",\n \"0.6947638\",\n \"0.69390184\",\n \"0.69115627\",\n \"0.69105035\",\n \"0.6857282\",\n \"0.6822706\",\n \"0.6779308\",\n \"0.66278255\",\n \"0.6605075\",\n \"0.6557178\",\n \"0.65434927\",\n \"0.6530906\",\n \"0.6432699\",\n \"0.6416121\",\n \"0.6377947\",\n \"0.6370534\",\n \"0.6358671\",\n \"0.63333696\",\n \"0.63289326\",\n \"0.63137287\",\n \"0.62564003\",\n \"0.6244648\",\n \"0.6224863\",\n \"0.62013537\",\n \"0.61988425\",\n \"0.6187764\",\n \"0.61603814\",\n \"0.61385304\",\n \"0.6131805\",\n \"0.6127906\",\n \"0.60852015\",\n \"0.6070042\",\n \"0.60562074\",\n \"0.6037569\",\n \"0.60275775\",\n \"0.6014558\",\n \"0.6005777\",\n \"0.59883803\",\n \"0.5960326\",\n \"0.5947174\",\n \"0.59320635\",\n \"0.5927931\",\n \"0.59246546\",\n \"0.591827\",\n \"0.5918045\",\n \"0.59104526\",\n \"0.5899391\",\n \"0.58970934\",\n \"0.5890145\",\n \"0.58890665\",\n \"0.58765054\",\n \"0.5874601\",\n \"0.5865692\",\n \"0.5864861\",\n \"0.5863782\",\n \"0.5859612\",\n \"0.5852797\",\n \"0.5850569\",\n \"0.5848066\",\n \"0.583693\",\n \"0.58226365\",\n \"0.58224344\",\n \"0.5815077\",\n \"0.579765\",\n \"0.5793366\",\n \"0.57921124\",\n \"0.57745117\",\n \"0.57732385\",\n \"0.57703453\",\n \"0.576477\",\n \"0.5764315\",\n \"0.57543075\",\n \"0.5753728\",\n \"0.5746822\",\n \"0.57420933\",\n \"0.5733583\",\n \"0.5732684\",\n \"0.57290894\",\n \"0.5727964\",\n \"0.5727313\",\n \"0.5727299\",\n \"0.5726123\",\n \"0.5722092\",\n \"0.5718592\",\n \"0.57179624\",\n \"0.57148004\",\n \"0.5711548\",\n \"0.57034266\",\n \"0.5702801\",\n \"0.57012343\",\n \"0.5700788\",\n \"0.5700273\",\n \"0.56985605\",\n \"0.56832385\",\n \"0.5682147\",\n \"0.56815153\",\n \"0.5676475\",\n \"0.5671381\",\n \"0.56617546\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.643053"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":14869,"cells":{"query":{"kind":"string","value":"Convert unit conversion with custom UnitRegistry"},"document":{"kind":"string","value":"def test_convert_unit_with_custom_registry(test_df):\n df = get_units_test_df(test_df).rename(unit={\"EJ/yr\": \"foo\"})\n\n # check that conversion fails with application registry\n with pytest.raises(pint.UndefinedUnitError):\n df.convert_unit(\"foo\", \"baz\")\n\n # define a custom unit registry\n ureg = pint.UnitRegistry()\n ureg.define(\"baz = [custom]\")\n ureg.define(\"foo = 3 * baz\")\n\n exp = pd.Series([1.0, 6.0, 1.5, 9, 6, 21], name=\"value\")\n assert_converted_units(df, \"foo\", \"baz\", exp, registry=ureg)"},"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 _convert_unit(self, unit):\n if unit in self.units:\n return self.units[unit]\n elif unit in unit_map:\n return unit_map[unit]\n else:\n raise SBMLError('Unit not recognized: ' + str(unit))","def convertUnit(*args, fromUnit: AnyStr=\"\", toUnit: AnyStr=\"\", **kwargs)->float:\n pass","def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\n return process_unit_input(value, units, convert=True, registry=registry).v","def useUnits():","def to_unit(self, unit):\n unit = _find_unit(unit)\n self.value = _convert_value(self.value, self.unit, unit)\n self.unit = unit","def convert(x, unit1, unit2):\r\n return conversions[unit1][unit2](x)","def SBMLUnitsConverter_init():\n return _libsbml.SBMLUnitsConverter_init()","def convert_units(self, units):\n self.unit_array = self.unit_array.to(units)","def convert_units(data, units):\n # Build the dictionary of units conversions\n convert = {'m' : [1.0, 0., 'm'], \n 'meter' : [1.0, 0., 'm'], \n 'deg C' : [1.0, 273.15, 'K'], \n 'Celsius' : [1.0, 273.15, 'K'], \n 'K' : [1.0, 0., 'K'],\n 'db' : [1.e4, 101325., 'Pa'], \n 'Pa' : [1.0, 0., 'Pa'],\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \n 'S/m': [1.0, 0., 'S/m'],\n 'mS/m' : [1.e-3, 0., 'S/m'],\n 'psu': [1.0, 0., 'psu'], \n 'salinity': [1.0, 0., 'psu'], \n 'kg/m^3': [1.0, 0., 'kg/m^3'], \n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \n 'm/s': [1.0, 0., 'm/s'], \n 'mg/l': [1.e-3, 0., 'kg/m^3'],\n 'meter second-1' : [1.0, 0., 'm/s'],\n 'm.s-1' : [1.0, 0., 'm/s'],\n 'pH units' : [1.0, 0., 'pH units'],\n 'MPa' : [1.e6, 0., 'Pa'],\n '--' : [1.0, 0., '--'],\n 'mD' : [9.869233e-16, 0., 'm^2'],\n 'um' : [1.e-6, 0., 'm'],\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\n 'wt.%' : [10., 0., 'psu'],\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\n 'm^2' : [1., 0., 'm^2'],\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \n } \n \n # Make sure the data are a numpy array and the units are a list\n if isinstance(data, float) or isinstance(data, int):\n data = np.array([data])\n if isinstance(data, list):\n data = np.array(data)\n if isinstance(units, str) or isinstance(units, unicode):\n units = [units]\n if units == None:\n units = ['']\n \n # Make sure you can slice through the columns: must be two-dimensional\n sh = data.shape\n data = np.atleast_2d(data)\n \n # Allow conversion of a row of data if all of the same unit\n if len(units) == 1 and data.shape[1] > 1:\n data = data.transpose()\n \n # Create an emtpy array to hold the output\n out_data = np.zeros(data.shape)\n out_units = []\n \n # Convert the units\n for i in range(len(units)):\n try:\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\n convert[units[i]][1]\n out_units += [convert[units[i]][2]]\n except KeyError:\n print('Do not know how to convert %s to mks units' % units[i])\n print('Continuing without converting these units...')\n out_data[:,i] = data[:,i]\n out_units += units[i]\n \n # Return the converted data in the original shape\n out_data = np.reshape(out_data, sh, 'C')\n return (out_data, out_units)","def fits_to_units(unit_str):\n unit_lookup = {\n 'meters': 'm',\n 'meter': 'm',\n 'degrees': 'deg',\n 'degree': 'deg',\n 'hz': 'Hz',\n 'hertz': 'Hz',\n 'second': 's',\n 'sec': 's',\n 'secs': 's',\n 'days': 'd',\n 'day': 'd',\n 'steradians': 'sr',\n 'steradian': 'sr',\n 'radians': 'rad',\n 'radian': 'rad',\n 'jy': 'Jy',\n 'au': 'AU',\n }\n\n try:\n new_units = \"\"\n\n if unit_str is None:\n unit_str = ''\n unit_str = unit_str.lower()\n unit_list = unit_str.split(\"/\")\n\n for uu in unit_list:\n if uu.endswith(\"s\") and len(uu) > 1:\n uu = uu[:-1]\n corrected_unit = unit_lookup.get(uu, uu)\n new_units += corrected_unit\n new_units += \" / \"\n new_units = new_units[:-3]\n unit = Unit(new_units)\n return unit\n\n except ValueError:\n warnings.warn(\"Unknown unit: %s\" % new_units, UnitWarning)\n return UnrecognizedUnit(unit_str)","def test_convert_compatible_units(self):\n result = convert_units(self.arr, 'degC')\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\n expected_units = cf_units.Unit('degC')\n self.assertEquals(result.units, expected_units)\n self.assertArrayEqual(result.data, expected_data)","def test_convert_same_unit():\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5","def reload_unit_registry():\n\n import time\n t_start = time.time()\n\n global _unit_registry\n\n _unit_registry = None\n\n reg = pint.UnitRegistry()\n\n # Define some \"standard\" additional units\n reg.define('piece = 1')\n reg.define('each = 1 = ea')\n reg.define('dozen = 12 = dz')\n reg.define('hundred = 100')\n reg.define('thousand = 1000')\n\n # Allow for custom units to be defined in the database\n try:\n from common.models import CustomUnit\n\n for cu in CustomUnit.objects.all():\n try:\n reg.define(cu.fmt_string())\n except Exception as e:\n logger.error(f'Failed to load custom unit: {cu.fmt_string()} - {e}')\n\n # Once custom units are loaded, save registry\n _unit_registry = reg\n\n except Exception:\n # Database is not ready, or CustomUnit model is not available\n pass\n\n dt = time.time() - t_start\n logger.debug(f'Loaded unit registry in {dt:.3f}s')\n\n return reg","def assign_unit(self):\n self.units = {}\n for unit in RADIAL_UNITS:\n if unit.REPR == \"2th_deg\":\n self.units[unit] = self.tth_deg\n elif unit.REPR == \"2th_rad\":\n self.units[unit] = self.tth_rad\n elif unit.REPR == \"q_nm^-1\":\n self.units[unit] = self.q_nm\n elif unit.REPR == \"q_A^-1\":\n self.units[unit] = self.q_A\n elif unit.REPR == \"r_mm\":\n self.units[unit] = self.r_mm\n else:\n logger.warning(\"Unit unknown to GUI %s\" % unit)","def unit_registry_to_human_readable(unit_registry):\n if unit_registry is None:\n return None\n new_registry = {}\n integer_one = 1\n for k in SI_base_registry:\n if unit_registry[k] is integer_one:\n new_registry[k] = 1, 1\n else:\n dim_list = list(unit_registry[k].dimensionality)\n if len(dim_list) != 1:\n raise TypeError(\"Compound units not allowed: {}\".format(dim_list))\n u_symbol = dim_list[0].u_symbol\n new_registry[k] = float(unit_registry[k]), u_symbol\n return new_registry","def convert(self):\n return _libsbml.SBMLUnitsConverter_convert(self)","def convert_units(value, from_unit, to_unit, **args):\n\n # Check if units can be converted\n if not can_convert(from_unit, to_unit):\n return '[!] Units cannot be converted\\n'\n\n # Extract the numeric value from the string\n decimal_places = 2 # Set the default value of precision\n if \".\" in str(value):\n decimal_places = len(str(value)[str(value).index('.') + 1:])\n\n # Return the value if units are the same\n if from_unit == to_unit:\n return str(value) + \" \" + get_si(to_unit)\n\n responses = [\n check_time(value, from_unit, to_unit, decimal_places), # Time units\n check_metric_imperial(\n value,\n from_unit,\n to_unit,\n decimal_places), # Metric and Imperial units\n check_digital_storage(\n value,\n from_unit,\n to_unit,\n decimal_places\n ) # Digital storage units\n ]\n\n for response in responses:\n if response:\n return response\n\n # actually convert the units\n try:\n return str(round(convert(from_unit, to_unit, float(value), **args), decimal_places)) + \" \" + get_si(to_unit)\n except RequireAdditionalParamError as e:\n additional_unit = input(\"\\n[*] Enter an additional unit (choose between \" + str(e.additional_params) + \"): \")\n additional_value = float(input(\"\\n[*] Enter the value: \"))\n return convert_units(value, from_unit, to_unit, **{additional_unit: additional_value})\n except ConversionError as e:\n print(e.reason)","def spice_unit_convert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result /= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result *= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\n result *= numeric(spice_unit_unconvert([part, \"1.0\"], restrict))\n return str(result)\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n else:\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n newvalue = numeric(valuet[1]) * 0.01\n return str(newvalue)\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def convert_units(unt, origunits):\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\n units = origunits\n convf = 1\n else:\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'met':\n units = 'feet'\n convf = 3.2808399\n else:\n units = origunits\n convf = 1\n else:\n if 'met' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'fee':\n units = 'meters'\n convf = 0.3048\n else:\n units = origunits\n convf = 1\n else:\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'kno':\n units = 'meters/sec'\n convf = 0.51444444\n else:\n units = origunits\n convf = 1\n else:\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'm/s':\n units = 'knots'\n convf = 1.9438445\n else:\n units = origunits\n convf = 1\n else:\n error('Unknown units')\n #\n return units, convf","def init():\n return _libsbml.SBMLUnitsConverter_init()","def test_unit_conversion(self):\n self.cube_uv_down.convert_units(\"kW m-2\")\n scale_factor = 1.0\n expected = np.full_like(\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\n )\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\n self.assertArrayEqual(result.data, expected)","def convert_unit(self, time_unit):\r\n\r\n self.time_unit = time_unit\r\n self._conversion_factor = time_unit_conversion[time_unit]","def unit2internal(src_unit: Union[str, float]):\n return _parse_unit(src_unit, conversion_factor=_conversion_factor_internal)","def units_to_fits(unit):\n if unit is None:\n unit = Unit('')\n return unit.to_string(\"fits\").upper()","def get_converted_si_unit():\n units = request.args.get('units')\n response = ConvertUnit(units).convert()\n return jsonify(response)","def to(self, new_unit, **kwargs):\n new_unit = u.Unit(new_unit)\n return self * (self.unit.to(new_unit, **kwargs) * new_unit / self.unit)","def unit_converter(val, from_u, to_u):\n\tconverter = {'b':0, 'k':1, 'm':2, 'g':3, 't':4}\n\tif converter[from_u] < converter[to_u]:\n\t\tval = float(val)\n\t\tfor _ in range(converter[to_u] - converter[from_u]):\n\t\t\tval = val/1024\n\telse:\n\t\tfor _ in range(converter[from_u] - converter[to_u]):\n\t\t\tval = val * 1024\n\t\t\t\n\treturn val","def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)","def _conversion_factor_internal(unit: str):\n return globals()[unit]","def convert(self, value, units, newunits):\n return value * self._units[units] / self._units[newunits]","def resolve_units(obj, _):\n return obj.units.decode()","def Unit_convertToSI(*args):\n return _libsbml.Unit_convertToSI(*args)","def parse_unit(unit_string):\n with warnings.catch_warnings():\n warnings.filterwarnings('ignore', module='astropy')\n try:\n unit = u.Unit(unit_string, parse_strict='raise')\n except ValueError:\n new_string = unit_string.replace('(cm-1)', 'kayser')\n log.debug(f'\\tValue Error, try {new_string}')\n unit = u.Unit(new_string,\n parse_strict='silent')\n log.debug(f'Parsed {unit_string} into {unit} ({type(unit)}).')\n return unit","def convert_units(celsius_value, units):\n if units == 0:\n return celsius_value\n if units == 1:\n return celsius_value * 1.8 + 32\n return celsius_value + 273.15","def convert_to_unit(self, data, unit):\n\n res = OrderedDict()\n\n # Loop over data and overwrite\n for ch in data:\n _idx = self.channels.index(ch)\n # Get data, scale and type of channel\n val, scale, _type = data[ch], self.daq_setup['devices']['adc']['ro_scales'][_idx], self.daq_setup['devices']['adc']['types'][_idx]\n # Adjust scale in case we're looking at SEM's sum signal; in this case current is multiplied by factor of 4\n scale *= 1 if _type != 'sem_sum' else 4\n\n res[ch] = val / 5.0 * scale * 1e-9 if unit == 'A' else val * 5.0 / 1e-9 / scale\n\n return res","def to_base_unit(val: float, unit: str = \"\") -> float:\n unit_scalar = UNITS.get(unit, None)\n if not unit_scalar:\n raise UnknownUnitError(f\"Unit '{unit}' is not supported\")\n\n return val * unit_scalar","def describe_a_library_of_units_converters_that():\n def blows_smoke():\n assert True\n\n def can_convert_psi_to_kpa():\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\n\n # def can_convert_kpa_to_psi():\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\n\n # def can_convert_mpg_to_lp100k():\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\n\n # def can_convert_lp100k_to_mpg():\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg","def convert_to(self, units: str) -> None:\n if self.units == units:\n return\n\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\n msg = f\"\"\"Not a valid unit conversion. Valid destination units:\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\"\"\"\n raise ValueError(msg)\n\n if self.units == \"celsius\" and units == \"fahrenheit\":\n self._celsius_to_fahrenheit()\n elif self.units == \"m/s\" and units == \"km/h\":\n self._mps_to_kph()\n elif self.units == \"m/s\" and units == \"mph\":\n self._mps_to_mph()\n else:\n raise ValueError(\"Not a valid unit conversion.\")","def parse_unit(self, unitelem) -> Unit:\n u = Unit()\n\n u.unitid = unitelem.attrib['id'].strip()\n div = unitelem.find('{*}divide')\n if div is not None:\n nom = div.find('{*}unitNumerator').find('{*}measure')\n denom = div.find('{*}unitDenominator').find('{*}measure')\n u.nom = re.sub('.*:', '', nom.text).lower()\n u.denom = re.sub('.*:', '', denom.text).lower()\n else:\n m = unitelem.find('{*}measure')\n u.nom = re.sub('.*:', '', m.text).lower()\n\n return u","def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6","def test_convert_unit_with_custom_factor(test_df):\n # unit conversion with custom factor\n df = get_units_test_df(test_df)\n exp = pd.Series([1.0, 6.0, 1.0, 6.0, 4.0, 14.0], name=\"value\")\n assert_converted_units(df, \"EJ/yr\", \"foo\", exp, factor=2)","def convert_units(cube, units):\n try:\n cube.convert_units(units)\n except ValueError:\n if not _try_special_conversions(cube, units):\n raise\n\n return cube","def _replace_units(original_units, values_by_name):\n q = 1\n for arg_name, exponent in original_units.items():\n q = q * values_by_name[arg_name] ** exponent\n\n return getattr(q, \"_units\", UnitsContainer({}))","def convert(self):\n return _libsbml.SBMLInferUnitsConverter_convert(self)","def _get_units_object(self, units):\n if isinstance(units, cellml_units):\n # We're done\n pass\n else:\n units = amara_parse_cellml(unicode(units))\n assert isinstance(units, cellml_units)\n return units","def convert_F_units(F, lbda, in_unit='cgs', out_unit='si'):\n\n if in_unit == 'cgs':\n new_F = (F*1e23*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == 'cgsA':\n new_F = (F*1e27*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == 'si':\n new_F = (F*1e26*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == \"jy\":\n new_F=F\n else:\n msg = \"in_unit not recognized, try either 'cgs', 'si' or 'jy'.\"\n raise TypeError(msg) \n if out_unit == 'jy':\n return new_F\n elif out_unit == 'cgs':\n return new_F*1e-23*c.c.value*1e6/np.power(lbda,2)\n elif out_unit == 'si':\n return new_F*1e-26*c.c.value*1e6/np.power(lbda,2)\n else:\n msg = \"out_unit not recognized, try either 'cgs', 'si' or 'jy'.\"\n raise TypeError(msg)","def cast_value(value, unit):\n if isinstance(value, u.Quantity):\n return value.to(unit)\n return value * unit","def convert_units(data, hdr, conv_to = \"surf_br\"):\n \n data_unit = hdr[\"SIGUNIT\"]\n \n if \"Jy/pix\" in data_unit:\n # pixel size in rad\n px_x = abs(hdr[\"CDELT1\"])*2*np.pi/360\n px_y = abs(hdr[\"CDELT2\"])*2*np.pi/360\n \n #pixel size in arcsec\n \n px_x = abs(hdr[\"CDELT1\"])*3600\n px_y = abs(hdr[\"CDELT2\"])*3600\n conversion_factor = 1000/(px_x*px_y)\n \n unit_label = \"mJy/arcsec^2\"\n \n #in case we want to convert to units flux, we need to multiply by the size (in steradians) of a pixel.\n if conv_to == \"flux\":\n conversion_factor*=abs(hdr[\"CDELT1\"])*abs(hdr[\"CDELT2\"])*(2*np.pi/360)**2\n unit_label = \"mJy\"\n \n data *= conversion_factor\n hdr[\"SIGUNIT\"] = unit_label\n else:\n print(\"\\t[WARNING]\\t \"+data_unit+\" conversion not yet implemented. No conversion performed.\")\n \n return data, hdr","def convert(obj, unit, axis):\r\n return obj","def convert_string_to_unit(s):\n \n if \":\" not in s:\n match = UNIT_RE.match(s)\n if match:\n s = \"%s:%s\"%match.groups()\n \n return Unit(s)","def convert_units(self, time_units=None, len_units=None):\n in_time = self.time_units\n # Check new time units\n if time_units is None:\n time_units = in_time\n flag = _units.validate_units(time_units)\n if flag == -1:\n raise ValueError('Bad time units input {}'.format(time_units))\n # Check new length units\n in_len = self.len_units\n if len_units is None:\n len_units = in_len\n flag = _units.validate_units(len_units)\n if flag == -1:\n raise ValueError('Bad length units input {}'.format(len_units))\n # Convert parameters units\n for key, value in self.parameters.items():\n if type(value) in [int, float]:\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\n # Convert drawdown data\n self.drawdown.convert_units(time_units, len_units)\n # Convert associate data units\n for i in range(self.data_count()):\n if self.data[i].dtype == 1: # drawdown units\n data_units = len_units\n elif self.data[i].dtype == 2: # first derivative units\n data_units = len_units + \"/\" + time_units\n elif self.data[i].dtype == 3: # second derivative units\n data_units = len_units + \"/\" + time_units + \"2\"\n self.data[i].convert_units(time_units, data_units)\n self.len_units = len_units\n self.time_units = time_units\n # End Function","def unit(self,unit_str,unit_scale):\n self.units[unit_str] = unit_scale\n return self","def convert_from_to(from_unit, to_unit, quantity):\n if not is_valid_unit(from_unit):\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\n if not is_valid_unit(to_unit):\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]","def convertUnits(self, unitMap):\n\n for child in Resonances.ancestryMembers:\n if getattr(self, child) is not None:\n getattr(self, child).convertUnits(unitMap)","def SBMLInferUnitsConverter_init():\n return _libsbml.SBMLInferUnitsConverter_init()","def consume_units(self, units):\n pass","def get_converted_unit(\n self,\n device_class: SensorDeviceClass | str | None,\n original_unit: str | None,\n ) -> str | None:\n return self._conversions.get((device_class, original_unit))","def test_convert_unit_from_repo(test_df):\n df = get_units_test_df(test_df)\n exp = pd.Series([1.0, 6.0, 17.06, 102.361, 68.241, 238.843], name=\"value\")\n assert_converted_units(df, \"EJ/yr\", \"Mtce/yr\", exp)","def unit_convert(df, coln1, coln2, unit, conversion_factor, coln3):\n df.loc[df[coln2] == unit, coln1] = conversion_factor * df[coln3]\n return df","def convertToSI(*args):\n return _libsbml.Unit_convertToSI(*args)","def set_unit(self,unit):\n self.unit = unit","def _get_units(self):\n #assert self.ser.isOpen()\n\n self.serial_connection.write('UNI' + self.CR + self.LF)\n acknowledgement = self.serial_connection.readline()\n self._check_acknowledgement(acknowledgement)\n\n self.serial_connection.write(self.ENQ)\n unit = self.MEASUREMENT_UNITS[self.serial_connection.readline().rstrip(self.LF).rstrip(self.CR)]\n\n self.serial_connection.write(self.CR + self.LF)\n\n return unit","def spice_unit_unconvert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item / spice_unit_unconvert([parts[1], 1.0],\n\t\t\trestrict) for item in result)\n else:\n result /= spice_unit_unconvert([parts[1], 1.0], restrict)\n return result\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item * spice_unit_unconvert([parts[1], 1.0],\n\t\t\trestrict) for item in result)\n else:\n result *= spice_unit_unconvert([parts[1], 1.0], restrict)\n return result\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = spice_unit_unconvert([part, valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item * spice_unit_unconvert([part, 1.0],\n\t\t\trestrict) for item in result)\n else:\n result *= spice_unit_unconvert([part, 1.0], restrict)\n return result\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n if isinstance(valuet[1], list):\n return list(item / prefixtypes[prerec] for item in valuet[1])\n else:\n return valuet[1] / prefixtypes[prerec]\n else:\n if isinstance(valuet[1], list):\n return list(item / prefixtypes[prerec] for item in valuet[1])\n else:\n return valuet[1] / prefixtypes[prerec]\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n if isinstance(valuet[1], list):\n return list(item * 100 for item in valuet[1])\n else:\n return valuet[1] * 100\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def load_unit(self, unit_id):","def UnitDefinition_convertToSI(*args):\n return _libsbml.UnitDefinition_convertToSI(*args)","def convert( self, values, unit, toUnit ):\n\n if unit == toUnit: return values\n\n #-----------------------------------------------------------------\n # Check for unit validity \n #-----------------------------------------------------------------\n\n if unit != acuUnit.getBaseUnit( toUnit ):\n raise AcuDbAssistError, \"Invalid unit argument to get adbValues.\"\n \n #-----------------------------------------------------------------\n # Convert base unit to given unit\n #-----------------------------------------------------------------\n\n return self.cnvValues( values, unit, toUnit )","def to_unit_validator(compatible_units):\n def _to_unit_validator(quantity_str):\n return process_unit_bearing_str(quantity_str, compatible_units)\n return _to_unit_validator","def convert_units(array, in_units=\"None\"):\n if in_units == \"None\" or in_units is None:\n return array\n else:\n raise Exception(\"Unsupported unit for bispectrum descriptors.\")","def convertToSI(*args):\n return _libsbml.UnitDefinition_convertToSI(*args)","def unit(x,convert_to=\"px\",from_unit=\"px\"):\n assert convert_to in UNITS, \"Cannot convert to unknown unit: %s\" % convert_to\n assert from_unit in UNITS, \"Cannot from unknown unit: %s\" % from_unit\n return float(x)*UNITS[convert_to]/UNITS[from_unit]","def get_units(self):\r\n msg = struct.pack('>2B', 56, 14)\r\n response = self.query(msg)\r\n\r\n if response[1] == 2:\r\n units = 'A'\r\n to_nm_multiplier = 1 / 10\r\n elif response[1] == 1:\r\n units = 'nm'\r\n to_nm_multiplier = 1\r\n elif response[1] == 0:\r\n units = 'um'\r\n to_nm_multiplier = 1000\r\n else:\r\n raise ValueError('Units not recognised.')\r\n\r\n # Save results locally too for quick re-use\r\n self._current_units = units\r\n self._current_to_nm_multiplier = to_nm_multiplier\r\n\r\n return units, to_nm_multiplier","def convertUnits(self, varname, arr):\n if varname == \"SPDQ\" or varname == \"PHQ\":\n return arr*2.5e6/1000.\n return arr","def get_unit(shared, unit_name):\n if (shared.config.get_safe('data', 'use_units') != 'off'):\n unit_val, unit_str = shared.config.get_safe_literal('units', unit_name,\n default=(1.0, ''))\n if unit_str:\n unit_str = ' [' + unit_str + ']'\n else:\n unit_val = 1.0\n unit_str = ''\n \n return unit_val, unit_str","def tranfer_unit(number):\n count = 0\n unit_name = \"\"\n if 2 ** 20 > number > 2 ** 10:\n unit_name = \"Kb\"\n count = 1\n elif 2 ** 30 > number > 2 ** 20:\n unit_name = \"Mb\"\n count = 2\n elif number > 2 ** 30:\n unit_name = \"Gb\"\n count = 3\n else:\n unit_name = \"b\"\n if count != 0:\n unit_number = round(number / ((2 ** 10) ** count), 2)\n else:\n unit_number = round(number, 2)\n unit_str = \"{num}{name}\".format(num=unit_number, name=unit_name)\n return unit_str","def _convert_value(self, value, unit, axis):\n if hasattr(value, 'units'):\n return value.to(unit).magnitude\n else:\n return self._reg.Quantity(value, axis.get_units()).to(unit).magnitude","def tempConvert(temp, unit):\n if unit == 'F':\n celsius = (temp - 32) * 5 / 9\n return celsius\n else:\n return temp","def _add_converted_units(self, dataframe, parameter, key='VALUE'):\n convert_unit = self.parameters.get_converter(parameter)\n try:\n dataframe[key] = dataframe['DATA_VALUE'].apply(convert_unit)\n except KeyError:\n log.warn(\"Missing 'VALUE': no unit conversion.\")\n else:\n dataframe.unit = self.parameters.unit(parameter)","def test_change_units(self):\n s = State(\"water\", T=Q_(100, \"degC\"), p=Q_(1.0, \"atm\"), units=\"EE\")\n assert s.units == \"EE\"\n s.units = \"SI\"\n assert s.units == \"SI\"\n assert s.cv.units == \"kilojoule / kelvin / kilogram\"\n assert s.cp.units == \"kilojoule / kelvin / kilogram\"\n assert s.s.units == \"kilojoule / kelvin / kilogram\"\n assert s.h.units == \"kilojoule / kilogram\"\n assert s.T.units == \"degree_Celsius\"\n assert s.u.units == \"kilojoule / kilogram\"\n assert s.v.units == \"meter ** 3 / kilogram\"\n assert s.p.units == \"bar\"","def test_convert_unit_bad_args(test_pd_df):\n idf = IamDataFrame(test_pd_df).rename(unit={\"EJ/yr\": \"Mt CH4\"})\n\n # Conversion fails with both *factor* and *registry*\n with pytest.raises(ValueError, match=\"Use either `factor` or `registry`!\"):\n idf.convert_unit(\"Mt CH4\", \"CO2e\", factor=1.0, registry=object())\n\n # Conversion fails with an invalid registry\n with pytest.raises(TypeError, match=\"must be `pint.UnitRegistry`\"):\n idf.convert_unit(\"Mt CH4\", \"CO2e\", registry=object())\n\n # Conversion fails without context; exception provides a usage hint\n match = r\"GWP conversion with IamDataFrame.convert_unit\\(\\) requires...\"\n with pytest.raises(pint.UndefinedUnitError, match=match):\n idf.convert_unit(\"Mt CH4\", \"CO2e\")","def _to(\n value: Union[\"Value\", \"ValueArray\"], units: Union[Unit, str], inplace: bool\n) -> Any:\n if value.units == units:\n return value\n\n if value.units is None:\n raise RuntimeError(\"Cannot convert with units=None\")\n\n try:\n units = next(\n imp_unit\n for imp_unit in value.implemented_units\n if units.lower() in imp_unit.aliases\n )\n\n except StopIteration:\n raise TypeError(\n f\"No viable unit conversion from {value.units} -> {units}\"\n )\n\n if not (isinstance(value, Value) or isinstance(value, ValueArray)):\n raise ValueError(\n f\"Cannot convert {value} to new units. Must be one of\"\n f\" Value of ValueArray\"\n )\n\n if isinstance(value, Value) and inplace:\n raise ValueError(\n \"Cannot modify a value inplace as floats are immutable\"\n )\n\n # Convert to the base unit, then to the new units\n c = float(units.conversion / value.units.conversion)\n\n new_value = value if inplace else value.copy()\n new_value *= c\n new_value.units = units\n\n return None if inplace else new_value","def _parse_units(self, model, comp, node):\n node = dom_child(node, 'unitDefinition')\n while node:\n name = node.getAttribute('id')\n self.log('Parsing unit definition for \"' + name + '\".')\n unit = myokit.units.dimensionless\n node2 = dom_child(node, 'listOfUnits')\n node2 = dom_child(node2, 'unit')\n while node2:\n kind = str(node2.getAttribute('kind')).strip()\n u2 = self._convert_unit(kind)\n if node2.hasAttribute('multiplier'):\n m = float(node2.getAttribute('multiplier'))\n else:\n m = 1.0\n if node2.hasAttribute('scale'):\n m *= 10 ** float(node2.getAttribute('scale'))\n u2 *= m\n if node2.hasAttribute('exponent'):\n u2 **= float(node2.getAttribute('exponent'))\n unit *= u2\n node2 = dom_next(node2, 'unit')\n self.units[name] = unit\n node = dom_next(node, 'unitDefinition')","def test_unit_conversion_incompatible(self):\n self.orography_cube.units = 'K'\n msg = \"Unable to convert from\"\n with self.assertRaisesRegex(ValueError, msg):\n self.plugin_instance.process(self.orography_cube)","def convert_volume(self, event):\n try:\n #Compare other unit to one unit(cubic decimeters)\n current_value, current_unit = float(\"0\" + str(self.v.get())), self.dropdown.get()\n unit_comp = {\"acre foot\": 1233481.837548, \"barrels\": 158.987295, \"bushels(UK)\": 36.36872, \"bushels(US)\": 35.23907, \"centiliters\": 0.01, \"cubic centimeters\": 0.001, \"cubic decameters\": 1000000.0, \"cubic decimeters\": 1.0, \"cubic feet\": 28.316847, \"cubic inches\": 0.016387, \"cubic kilometers\": 1000000000000.0, \"cubic meters\": 1000.0, \"cubic mile\": 4168181825000.0, \"cubic millimeters\": 1e-06, \"cubic yards\": 764.554858, \"cups\": 0.236588, \"deciliters\": 0.1, \"dram\": 0.003697, \"dram(imperial)\": 0.003552, \"fluid ounces(US)\": 0.029574, \"fluid ounces(imperial)\": 0.028413, \"gallons(US,dry)\": 4.404884, \"gallons(US,liquid)\": 3.785412, \"gallons(imperial)\": 4.54609, \"gill(US)\": 0.118294, \"gill(imperial)\": 0.142065, \"liters\": 1.0, \"liters(1901-1964)\": 1.000028, \"microliters\": 1e-06, \"milliliters\": 0.001, \"nanoliters\": 1e-09, \"picoliters\": 1e-12, \"pints(US,dry)\": 0.55061, \"pints(US,liquid)\": 0.473176, \"pints(imperial)\": 0.568261, \"quarts(UK,dry)\": 1.101221, \"quarts(US,liquid)\": 0.946353, \"quarts(imperial)\": 1.136523, \"table spoons\": 0.014787, \"tea spoons\": 0.004929}\n value_comp, printer = current_value * unit_comp[current_unit], \"\"\n unit_list = sorted(unit_comp.keys())\n unit_list.remove(current_unit)\n for unit in unit_list:\n printer += \"To %s \" % unit + \" \" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\"\", \"\\n\"][unit_list[-1] != unit]\n except ValueError: #In case user enter the other type of value, not Int or Float\n printer = \"Value is invalid.\"\n self.print_text(printer)","def add_special_conversion(self, from_units, to_units, converter):\n self.special_conversions[(from_units, to_units)] = converter","def get_unit_registry():\n\n global _unit_registry\n\n # Cache the unit registry for speedier access\n if _unit_registry is None:\n return reload_unit_registry()\n else:\n return _unit_registry","def convert(value, unit, axis):\n converted_value = value\n if isinstance(unit, str) or isinstance(unit, Unit):\n unit = (unit,)\n if isinstance(value, (unyt_array, unyt_quantity)):\n converted_value = value.to(*unit)\n else:\n value_type = type(value)\n converted_value = []\n for obj in value:\n converted_value.append(obj.to(*unit))\n converted_value = value_type(converted_value)\n return converted_value","def _to_lems_unit(unit):\n if type(unit) == str:\n strunit = unit\n else:\n strunit = unit.in_best_unit()\n strunit = strunit[3:] # here we substract '1. '\n strunit = strunit.replace('^', '') # in LEMS there is no ^\n return strunit","def _override_units_system(self):\n try:\n f = open(self.filename+\".units\")\n except OSError:\n return\n\n name_mapping = {'pos': 'distance', 'vel': 'velocity'}\n units_dict = {}\n\n for line in f:\n if (not line.startswith(\"#\")):\n if \":\" not in line:\n raise OSError(\"Unknown format for units file %r\"%(self.filename+\".units\"))\n else:\n t, u = list(map(str.strip,line.split(\":\")))\n t = name_mapping.get(t,t)\n units_dict[t] = u\n\n self.set_units_system(**units_dict)","def to(self, unit, equivalencies=[], freq=None):\n\n if not isinstance(unit, u.Unit):\n unit = u.Unit(unit)\n\n if unit == self.unit:\n # No copying\n return self\n\n if ((self.unit.is_equivalent(u.Jy / u.beam) and\n not any({u.Jy/u.beam, u.K}.issubset(set(eq)) for eq in equivalencies))):\n # the 'not any' above checks that there is not already a defined\n # Jy<->K equivalency. If there is, the code below is redundant\n # and will cause problems.\n\n if hasattr(self, 'beams'):\n factor = (self.jtok_factors(equivalencies=equivalencies) *\n (self.unit*u.beam).to(u.Jy))\n else:\n # replace \"beam\" with the actual beam\n if not hasattr(self, 'beam'):\n raise ValueError(\"To convert objects with Jy/beam units, \"\n \"the object needs to have a beam defined.\")\n brightness_unit = self.unit * u.beam\n\n # create a beam equivalency for brightness temperature\n if freq is None:\n try:\n freq = self.with_spectral_unit(u.Hz).spectral_axis\n except AttributeError:\n raise TypeError(\"Object of type {0} has no spectral \"\n \"information. `freq` must be provided for\"\n \" unit conversion from Jy/beam\"\n .format(type(self)))\n else:\n if not freq.unit.is_equivalent(u.Hz):\n raise u.UnitsError(\"freq must be given in equivalent \"\n \"frequency units.\")\n\n bmequiv = self.beam.jtok_equiv(freq)\n # backport to handle astropy < 3: the beam equivalency was only\n # modified to handle jy/beam in astropy 3\n if bmequiv[0] == u.Jy:\n bmequiv.append([u.Jy/u.beam, u.K, bmequiv[2], bmequiv[3]])\n\n factor = brightness_unit.to(unit,\n equivalencies=bmequiv + list(equivalencies))\n\n else:\n # scaling factor\n factor = self.unit.to(unit, equivalencies=equivalencies)\n\n converted_array = (self.quantity * factor).value\n\n # use private versions of variables, not the generated property\n # versions\n # Not entirely sure the use of __class__ here is kosher, but we do want\n # self.__class__, not super()\n new = self.__class__(value=converted_array, unit=unit, copy=True,\n wcs=self._wcs, meta=self._meta, mask=self._mask,\n header=self._header)\n\n return new","def set_units(self, units):\n self.units = units","def unit_conversion(thing, units, length=False):\n if 'n/a' == thing:\n return 'n/a'\n try:\n thing = round(thing * CONVERSION[units][0 + length], 2)\n except:\n thing = 'fubar'\n return thing, CONVERSION[units][2 + length]","def process_unit_input(in_,\n default_units: UnitLike = None,\n convert: bool = False,\n check_dims: bool = False,\n copy: bool = True,\n registry: unyt.UnitRegistry = None) -> unyt_array:\n parser = UnitInputParser(default_units=default_units,\n convert=convert,\n check_dims=check_dims,\n copy=copy,\n registry=registry)\n return parser.parse(in_)","def units(self, *args):\n u = self.parent.unit\n return tuple('%s%s' % (a, u) for a in args)","def test_unit_conversion_compatible(self):\n self.orography_cube.convert_units('ft')\n probability_cube = self.plugin_instance.process(self.orography_cube)\n self.assertIsInstance(probability_cube, iris.cube.Cube)\n self.assertSequenceEqual(probability_cube.shape,\n self.reference_cube.shape)","def init():\n return _libsbml.SBMLInferUnitsConverter_init()","def to(self, unit, equivalencies=[]):\n\n return super(BaseOneDSpectrum, self).to(unit, equivalencies, freq=None)","def unit_type(self) -> str:","def __init__(self, *args):\n this = _libsbml.new_SBMLUnitsConverter(*args)\n try: self.this.append(this)\n except: self.this = this","def get_units(self,):\n self.UNITS = {'pressure':'Pa',}\n return","def conv(old='auto', new='auto'):\n if old == new:\n return 1.\n for unittype in [lenunits, angunits, timunits, masunits, eneunits]:\n if old in unittype and new in unittype:\n return unittype[new] / unittype[old]\n\n raise ValueError('Units \\'{}\\' and \\'{}\\' unrecognized or '\n 'not of same unit type'.format(old, new))"],"string":"[\n \"def _convert_unit(self, unit):\\n if unit in self.units:\\n return self.units[unit]\\n elif unit in unit_map:\\n return unit_map[unit]\\n else:\\n raise SBMLError('Unit not recognized: ' + str(unit))\",\n \"def convertUnit(*args, fromUnit: AnyStr=\\\"\\\", toUnit: AnyStr=\\\"\\\", **kwargs)->float:\\n pass\",\n \"def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\\n return process_unit_input(value, units, convert=True, registry=registry).v\",\n \"def useUnits():\",\n \"def to_unit(self, unit):\\n unit = _find_unit(unit)\\n self.value = _convert_value(self.value, self.unit, unit)\\n self.unit = unit\",\n \"def convert(x, unit1, unit2):\\r\\n return conversions[unit1][unit2](x)\",\n \"def SBMLUnitsConverter_init():\\n return _libsbml.SBMLUnitsConverter_init()\",\n \"def convert_units(self, units):\\n self.unit_array = self.unit_array.to(units)\",\n \"def convert_units(data, units):\\n # Build the dictionary of units conversions\\n convert = {'m' : [1.0, 0., 'm'], \\n 'meter' : [1.0, 0., 'm'], \\n 'deg C' : [1.0, 273.15, 'K'], \\n 'Celsius' : [1.0, 273.15, 'K'], \\n 'K' : [1.0, 0., 'K'],\\n 'db' : [1.e4, 101325., 'Pa'], \\n 'Pa' : [1.0, 0., 'Pa'],\\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \\n 'S/m': [1.0, 0., 'S/m'],\\n 'mS/m' : [1.e-3, 0., 'S/m'],\\n 'psu': [1.0, 0., 'psu'], \\n 'salinity': [1.0, 0., 'psu'], \\n 'kg/m^3': [1.0, 0., 'kg/m^3'], \\n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \\n 'm/s': [1.0, 0., 'm/s'], \\n 'mg/l': [1.e-3, 0., 'kg/m^3'],\\n 'meter second-1' : [1.0, 0., 'm/s'],\\n 'm.s-1' : [1.0, 0., 'm/s'],\\n 'pH units' : [1.0, 0., 'pH units'],\\n 'MPa' : [1.e6, 0., 'Pa'],\\n '--' : [1.0, 0., '--'],\\n 'mD' : [9.869233e-16, 0., 'm^2'],\\n 'um' : [1.e-6, 0., 'm'],\\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\\n 'wt.%' : [10., 0., 'psu'],\\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\\n 'm^2' : [1., 0., 'm^2'],\\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \\n } \\n \\n # Make sure the data are a numpy array and the units are a list\\n if isinstance(data, float) or isinstance(data, int):\\n data = np.array([data])\\n if isinstance(data, list):\\n data = np.array(data)\\n if isinstance(units, str) or isinstance(units, unicode):\\n units = [units]\\n if units == None:\\n units = ['']\\n \\n # Make sure you can slice through the columns: must be two-dimensional\\n sh = data.shape\\n data = np.atleast_2d(data)\\n \\n # Allow conversion of a row of data if all of the same unit\\n if len(units) == 1 and data.shape[1] > 1:\\n data = data.transpose()\\n \\n # Create an emtpy array to hold the output\\n out_data = np.zeros(data.shape)\\n out_units = []\\n \\n # Convert the units\\n for i in range(len(units)):\\n try:\\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\\\\n convert[units[i]][1]\\n out_units += [convert[units[i]][2]]\\n except KeyError:\\n print('Do not know how to convert %s to mks units' % units[i])\\n print('Continuing without converting these units...')\\n out_data[:,i] = data[:,i]\\n out_units += units[i]\\n \\n # Return the converted data in the original shape\\n out_data = np.reshape(out_data, sh, 'C')\\n return (out_data, out_units)\",\n \"def fits_to_units(unit_str):\\n unit_lookup = {\\n 'meters': 'm',\\n 'meter': 'm',\\n 'degrees': 'deg',\\n 'degree': 'deg',\\n 'hz': 'Hz',\\n 'hertz': 'Hz',\\n 'second': 's',\\n 'sec': 's',\\n 'secs': 's',\\n 'days': 'd',\\n 'day': 'd',\\n 'steradians': 'sr',\\n 'steradian': 'sr',\\n 'radians': 'rad',\\n 'radian': 'rad',\\n 'jy': 'Jy',\\n 'au': 'AU',\\n }\\n\\n try:\\n new_units = \\\"\\\"\\n\\n if unit_str is None:\\n unit_str = ''\\n unit_str = unit_str.lower()\\n unit_list = unit_str.split(\\\"/\\\")\\n\\n for uu in unit_list:\\n if uu.endswith(\\\"s\\\") and len(uu) > 1:\\n uu = uu[:-1]\\n corrected_unit = unit_lookup.get(uu, uu)\\n new_units += corrected_unit\\n new_units += \\\" / \\\"\\n new_units = new_units[:-3]\\n unit = Unit(new_units)\\n return unit\\n\\n except ValueError:\\n warnings.warn(\\\"Unknown unit: %s\\\" % new_units, UnitWarning)\\n return UnrecognizedUnit(unit_str)\",\n \"def test_convert_compatible_units(self):\\n result = convert_units(self.arr, 'degC')\\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\\n expected_units = cf_units.Unit('degC')\\n self.assertEquals(result.units, expected_units)\\n self.assertArrayEqual(result.data, expected_data)\",\n \"def test_convert_same_unit():\\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5\",\n \"def reload_unit_registry():\\n\\n import time\\n t_start = time.time()\\n\\n global _unit_registry\\n\\n _unit_registry = None\\n\\n reg = pint.UnitRegistry()\\n\\n # Define some \\\"standard\\\" additional units\\n reg.define('piece = 1')\\n reg.define('each = 1 = ea')\\n reg.define('dozen = 12 = dz')\\n reg.define('hundred = 100')\\n reg.define('thousand = 1000')\\n\\n # Allow for custom units to be defined in the database\\n try:\\n from common.models import CustomUnit\\n\\n for cu in CustomUnit.objects.all():\\n try:\\n reg.define(cu.fmt_string())\\n except Exception as e:\\n logger.error(f'Failed to load custom unit: {cu.fmt_string()} - {e}')\\n\\n # Once custom units are loaded, save registry\\n _unit_registry = reg\\n\\n except Exception:\\n # Database is not ready, or CustomUnit model is not available\\n pass\\n\\n dt = time.time() - t_start\\n logger.debug(f'Loaded unit registry in {dt:.3f}s')\\n\\n return reg\",\n \"def assign_unit(self):\\n self.units = {}\\n for unit in RADIAL_UNITS:\\n if unit.REPR == \\\"2th_deg\\\":\\n self.units[unit] = self.tth_deg\\n elif unit.REPR == \\\"2th_rad\\\":\\n self.units[unit] = self.tth_rad\\n elif unit.REPR == \\\"q_nm^-1\\\":\\n self.units[unit] = self.q_nm\\n elif unit.REPR == \\\"q_A^-1\\\":\\n self.units[unit] = self.q_A\\n elif unit.REPR == \\\"r_mm\\\":\\n self.units[unit] = self.r_mm\\n else:\\n logger.warning(\\\"Unit unknown to GUI %s\\\" % unit)\",\n \"def unit_registry_to_human_readable(unit_registry):\\n if unit_registry is None:\\n return None\\n new_registry = {}\\n integer_one = 1\\n for k in SI_base_registry:\\n if unit_registry[k] is integer_one:\\n new_registry[k] = 1, 1\\n else:\\n dim_list = list(unit_registry[k].dimensionality)\\n if len(dim_list) != 1:\\n raise TypeError(\\\"Compound units not allowed: {}\\\".format(dim_list))\\n u_symbol = dim_list[0].u_symbol\\n new_registry[k] = float(unit_registry[k]), u_symbol\\n return new_registry\",\n \"def convert(self):\\n return _libsbml.SBMLUnitsConverter_convert(self)\",\n \"def convert_units(value, from_unit, to_unit, **args):\\n\\n # Check if units can be converted\\n if not can_convert(from_unit, to_unit):\\n return '[!] Units cannot be converted\\\\n'\\n\\n # Extract the numeric value from the string\\n decimal_places = 2 # Set the default value of precision\\n if \\\".\\\" in str(value):\\n decimal_places = len(str(value)[str(value).index('.') + 1:])\\n\\n # Return the value if units are the same\\n if from_unit == to_unit:\\n return str(value) + \\\" \\\" + get_si(to_unit)\\n\\n responses = [\\n check_time(value, from_unit, to_unit, decimal_places), # Time units\\n check_metric_imperial(\\n value,\\n from_unit,\\n to_unit,\\n decimal_places), # Metric and Imperial units\\n check_digital_storage(\\n value,\\n from_unit,\\n to_unit,\\n decimal_places\\n ) # Digital storage units\\n ]\\n\\n for response in responses:\\n if response:\\n return response\\n\\n # actually convert the units\\n try:\\n return str(round(convert(from_unit, to_unit, float(value), **args), decimal_places)) + \\\" \\\" + get_si(to_unit)\\n except RequireAdditionalParamError as e:\\n additional_unit = input(\\\"\\\\n[*] Enter an additional unit (choose between \\\" + str(e.additional_params) + \\\"): \\\")\\n additional_value = float(input(\\\"\\\\n[*] Enter the value: \\\"))\\n return convert_units(value, from_unit, to_unit, **{additional_unit: additional_value})\\n except ConversionError as e:\\n print(e.reason)\",\n \"def spice_unit_convert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result /= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result *= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\\n result *= numeric(spice_unit_unconvert([part, \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n else:\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n newvalue = numeric(valuet[1]) * 0.01\\n return str(newvalue)\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def convert_units(unt, origunits):\\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\\n units = origunits\\n convf = 1\\n else:\\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'met':\\n units = 'feet'\\n convf = 3.2808399\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'met' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'fee':\\n units = 'meters'\\n convf = 0.3048\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'kno':\\n units = 'meters/sec'\\n convf = 0.51444444\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'm/s':\\n units = 'knots'\\n convf = 1.9438445\\n else:\\n units = origunits\\n convf = 1\\n else:\\n error('Unknown units')\\n #\\n return units, convf\",\n \"def init():\\n return _libsbml.SBMLUnitsConverter_init()\",\n \"def test_unit_conversion(self):\\n self.cube_uv_down.convert_units(\\\"kW m-2\\\")\\n scale_factor = 1.0\\n expected = np.full_like(\\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\\n )\\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\\n self.assertArrayEqual(result.data, expected)\",\n \"def convert_unit(self, time_unit):\\r\\n\\r\\n self.time_unit = time_unit\\r\\n self._conversion_factor = time_unit_conversion[time_unit]\",\n \"def unit2internal(src_unit: Union[str, float]):\\n return _parse_unit(src_unit, conversion_factor=_conversion_factor_internal)\",\n \"def units_to_fits(unit):\\n if unit is None:\\n unit = Unit('')\\n return unit.to_string(\\\"fits\\\").upper()\",\n \"def get_converted_si_unit():\\n units = request.args.get('units')\\n response = ConvertUnit(units).convert()\\n return jsonify(response)\",\n \"def to(self, new_unit, **kwargs):\\n new_unit = u.Unit(new_unit)\\n return self * (self.unit.to(new_unit, **kwargs) * new_unit / self.unit)\",\n \"def unit_converter(val, from_u, to_u):\\n\\tconverter = {'b':0, 'k':1, 'm':2, 'g':3, 't':4}\\n\\tif converter[from_u] < converter[to_u]:\\n\\t\\tval = float(val)\\n\\t\\tfor _ in range(converter[to_u] - converter[from_u]):\\n\\t\\t\\tval = val/1024\\n\\telse:\\n\\t\\tfor _ in range(converter[from_u] - converter[to_u]):\\n\\t\\t\\tval = val * 1024\\n\\t\\t\\t\\n\\treturn val\",\n \"def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)\",\n \"def _conversion_factor_internal(unit: str):\\n return globals()[unit]\",\n \"def convert(self, value, units, newunits):\\n return value * self._units[units] / self._units[newunits]\",\n \"def resolve_units(obj, _):\\n return obj.units.decode()\",\n \"def Unit_convertToSI(*args):\\n return _libsbml.Unit_convertToSI(*args)\",\n \"def parse_unit(unit_string):\\n with warnings.catch_warnings():\\n warnings.filterwarnings('ignore', module='astropy')\\n try:\\n unit = u.Unit(unit_string, parse_strict='raise')\\n except ValueError:\\n new_string = unit_string.replace('(cm-1)', 'kayser')\\n log.debug(f'\\\\tValue Error, try {new_string}')\\n unit = u.Unit(new_string,\\n parse_strict='silent')\\n log.debug(f'Parsed {unit_string} into {unit} ({type(unit)}).')\\n return unit\",\n \"def convert_units(celsius_value, units):\\n if units == 0:\\n return celsius_value\\n if units == 1:\\n return celsius_value * 1.8 + 32\\n return celsius_value + 273.15\",\n \"def convert_to_unit(self, data, unit):\\n\\n res = OrderedDict()\\n\\n # Loop over data and overwrite\\n for ch in data:\\n _idx = self.channels.index(ch)\\n # Get data, scale and type of channel\\n val, scale, _type = data[ch], self.daq_setup['devices']['adc']['ro_scales'][_idx], self.daq_setup['devices']['adc']['types'][_idx]\\n # Adjust scale in case we're looking at SEM's sum signal; in this case current is multiplied by factor of 4\\n scale *= 1 if _type != 'sem_sum' else 4\\n\\n res[ch] = val / 5.0 * scale * 1e-9 if unit == 'A' else val * 5.0 / 1e-9 / scale\\n\\n return res\",\n \"def to_base_unit(val: float, unit: str = \\\"\\\") -> float:\\n unit_scalar = UNITS.get(unit, None)\\n if not unit_scalar:\\n raise UnknownUnitError(f\\\"Unit '{unit}' is not supported\\\")\\n\\n return val * unit_scalar\",\n \"def describe_a_library_of_units_converters_that():\\n def blows_smoke():\\n assert True\\n\\n def can_convert_psi_to_kpa():\\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\\n\\n # def can_convert_kpa_to_psi():\\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\\n\\n # def can_convert_mpg_to_lp100k():\\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\\n\\n # def can_convert_lp100k_to_mpg():\\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg\",\n \"def convert_to(self, units: str) -> None:\\n if self.units == units:\\n return\\n\\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\\n msg = f\\\"\\\"\\\"Not a valid unit conversion. Valid destination units:\\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\\\"\\\"\\\"\\n raise ValueError(msg)\\n\\n if self.units == \\\"celsius\\\" and units == \\\"fahrenheit\\\":\\n self._celsius_to_fahrenheit()\\n elif self.units == \\\"m/s\\\" and units == \\\"km/h\\\":\\n self._mps_to_kph()\\n elif self.units == \\\"m/s\\\" and units == \\\"mph\\\":\\n self._mps_to_mph()\\n else:\\n raise ValueError(\\\"Not a valid unit conversion.\\\")\",\n \"def parse_unit(self, unitelem) -> Unit:\\n u = Unit()\\n\\n u.unitid = unitelem.attrib['id'].strip()\\n div = unitelem.find('{*}divide')\\n if div is not None:\\n nom = div.find('{*}unitNumerator').find('{*}measure')\\n denom = div.find('{*}unitDenominator').find('{*}measure')\\n u.nom = re.sub('.*:', '', nom.text).lower()\\n u.denom = re.sub('.*:', '', denom.text).lower()\\n else:\\n m = unitelem.find('{*}measure')\\n u.nom = re.sub('.*:', '', m.text).lower()\\n\\n return u\",\n \"def convert_units(self):\\n for prod in (\\\"ier\\\", \\\"ier_inc_rain\\\"):\\n self.data[prod].data[:] /= 1e6\",\n \"def test_convert_unit_with_custom_factor(test_df):\\n # unit conversion with custom factor\\n df = get_units_test_df(test_df)\\n exp = pd.Series([1.0, 6.0, 1.0, 6.0, 4.0, 14.0], name=\\\"value\\\")\\n assert_converted_units(df, \\\"EJ/yr\\\", \\\"foo\\\", exp, factor=2)\",\n \"def convert_units(cube, units):\\n try:\\n cube.convert_units(units)\\n except ValueError:\\n if not _try_special_conversions(cube, units):\\n raise\\n\\n return cube\",\n \"def _replace_units(original_units, values_by_name):\\n q = 1\\n for arg_name, exponent in original_units.items():\\n q = q * values_by_name[arg_name] ** exponent\\n\\n return getattr(q, \\\"_units\\\", UnitsContainer({}))\",\n \"def convert(self):\\n return _libsbml.SBMLInferUnitsConverter_convert(self)\",\n \"def _get_units_object(self, units):\\n if isinstance(units, cellml_units):\\n # We're done\\n pass\\n else:\\n units = amara_parse_cellml(unicode(units))\\n assert isinstance(units, cellml_units)\\n return units\",\n \"def convert_F_units(F, lbda, in_unit='cgs', out_unit='si'):\\n\\n if in_unit == 'cgs':\\n new_F = (F*1e23*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == 'cgsA':\\n new_F = (F*1e27*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == 'si':\\n new_F = (F*1e26*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == \\\"jy\\\":\\n new_F=F\\n else:\\n msg = \\\"in_unit not recognized, try either 'cgs', 'si' or 'jy'.\\\"\\n raise TypeError(msg) \\n if out_unit == 'jy':\\n return new_F\\n elif out_unit == 'cgs':\\n return new_F*1e-23*c.c.value*1e6/np.power(lbda,2)\\n elif out_unit == 'si':\\n return new_F*1e-26*c.c.value*1e6/np.power(lbda,2)\\n else:\\n msg = \\\"out_unit not recognized, try either 'cgs', 'si' or 'jy'.\\\"\\n raise TypeError(msg)\",\n \"def cast_value(value, unit):\\n if isinstance(value, u.Quantity):\\n return value.to(unit)\\n return value * unit\",\n \"def convert_units(data, hdr, conv_to = \\\"surf_br\\\"):\\n \\n data_unit = hdr[\\\"SIGUNIT\\\"]\\n \\n if \\\"Jy/pix\\\" in data_unit:\\n # pixel size in rad\\n px_x = abs(hdr[\\\"CDELT1\\\"])*2*np.pi/360\\n px_y = abs(hdr[\\\"CDELT2\\\"])*2*np.pi/360\\n \\n #pixel size in arcsec\\n \\n px_x = abs(hdr[\\\"CDELT1\\\"])*3600\\n px_y = abs(hdr[\\\"CDELT2\\\"])*3600\\n conversion_factor = 1000/(px_x*px_y)\\n \\n unit_label = \\\"mJy/arcsec^2\\\"\\n \\n #in case we want to convert to units flux, we need to multiply by the size (in steradians) of a pixel.\\n if conv_to == \\\"flux\\\":\\n conversion_factor*=abs(hdr[\\\"CDELT1\\\"])*abs(hdr[\\\"CDELT2\\\"])*(2*np.pi/360)**2\\n unit_label = \\\"mJy\\\"\\n \\n data *= conversion_factor\\n hdr[\\\"SIGUNIT\\\"] = unit_label\\n else:\\n print(\\\"\\\\t[WARNING]\\\\t \\\"+data_unit+\\\" conversion not yet implemented. No conversion performed.\\\")\\n \\n return data, hdr\",\n \"def convert(obj, unit, axis):\\r\\n return obj\",\n \"def convert_string_to_unit(s):\\n \\n if \\\":\\\" not in s:\\n match = UNIT_RE.match(s)\\n if match:\\n s = \\\"%s:%s\\\"%match.groups()\\n \\n return Unit(s)\",\n \"def convert_units(self, time_units=None, len_units=None):\\n in_time = self.time_units\\n # Check new time units\\n if time_units is None:\\n time_units = in_time\\n flag = _units.validate_units(time_units)\\n if flag == -1:\\n raise ValueError('Bad time units input {}'.format(time_units))\\n # Check new length units\\n in_len = self.len_units\\n if len_units is None:\\n len_units = in_len\\n flag = _units.validate_units(len_units)\\n if flag == -1:\\n raise ValueError('Bad length units input {}'.format(len_units))\\n # Convert parameters units\\n for key, value in self.parameters.items():\\n if type(value) in [int, float]:\\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\\n # Convert drawdown data\\n self.drawdown.convert_units(time_units, len_units)\\n # Convert associate data units\\n for i in range(self.data_count()):\\n if self.data[i].dtype == 1: # drawdown units\\n data_units = len_units\\n elif self.data[i].dtype == 2: # first derivative units\\n data_units = len_units + \\\"/\\\" + time_units\\n elif self.data[i].dtype == 3: # second derivative units\\n data_units = len_units + \\\"/\\\" + time_units + \\\"2\\\"\\n self.data[i].convert_units(time_units, data_units)\\n self.len_units = len_units\\n self.time_units = time_units\\n # End Function\",\n \"def unit(self,unit_str,unit_scale):\\n self.units[unit_str] = unit_scale\\n return self\",\n \"def convert_from_to(from_unit, to_unit, quantity):\\n if not is_valid_unit(from_unit):\\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\\n if not is_valid_unit(to_unit):\\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]\",\n \"def convertUnits(self, unitMap):\\n\\n for child in Resonances.ancestryMembers:\\n if getattr(self, child) is not None:\\n getattr(self, child).convertUnits(unitMap)\",\n \"def SBMLInferUnitsConverter_init():\\n return _libsbml.SBMLInferUnitsConverter_init()\",\n \"def consume_units(self, units):\\n pass\",\n \"def get_converted_unit(\\n self,\\n device_class: SensorDeviceClass | str | None,\\n original_unit: str | None,\\n ) -> str | None:\\n return self._conversions.get((device_class, original_unit))\",\n \"def test_convert_unit_from_repo(test_df):\\n df = get_units_test_df(test_df)\\n exp = pd.Series([1.0, 6.0, 17.06, 102.361, 68.241, 238.843], name=\\\"value\\\")\\n assert_converted_units(df, \\\"EJ/yr\\\", \\\"Mtce/yr\\\", exp)\",\n \"def unit_convert(df, coln1, coln2, unit, conversion_factor, coln3):\\n df.loc[df[coln2] == unit, coln1] = conversion_factor * df[coln3]\\n return df\",\n \"def convertToSI(*args):\\n return _libsbml.Unit_convertToSI(*args)\",\n \"def set_unit(self,unit):\\n self.unit = unit\",\n \"def _get_units(self):\\n #assert self.ser.isOpen()\\n\\n self.serial_connection.write('UNI' + self.CR + self.LF)\\n acknowledgement = self.serial_connection.readline()\\n self._check_acknowledgement(acknowledgement)\\n\\n self.serial_connection.write(self.ENQ)\\n unit = self.MEASUREMENT_UNITS[self.serial_connection.readline().rstrip(self.LF).rstrip(self.CR)]\\n\\n self.serial_connection.write(self.CR + self.LF)\\n\\n return unit\",\n \"def spice_unit_unconvert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item / spice_unit_unconvert([parts[1], 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result /= spice_unit_unconvert([parts[1], 1.0], restrict)\\n return result\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item * spice_unit_unconvert([parts[1], 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result *= spice_unit_unconvert([parts[1], 1.0], restrict)\\n return result\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = spice_unit_unconvert([part, valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item * spice_unit_unconvert([part, 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result *= spice_unit_unconvert([part, 1.0], restrict)\\n return result\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n if isinstance(valuet[1], list):\\n return list(item / prefixtypes[prerec] for item in valuet[1])\\n else:\\n return valuet[1] / prefixtypes[prerec]\\n else:\\n if isinstance(valuet[1], list):\\n return list(item / prefixtypes[prerec] for item in valuet[1])\\n else:\\n return valuet[1] / prefixtypes[prerec]\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n if isinstance(valuet[1], list):\\n return list(item * 100 for item in valuet[1])\\n else:\\n return valuet[1] * 100\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def load_unit(self, unit_id):\",\n \"def UnitDefinition_convertToSI(*args):\\n return _libsbml.UnitDefinition_convertToSI(*args)\",\n \"def convert( self, values, unit, toUnit ):\\n\\n if unit == toUnit: return values\\n\\n #-----------------------------------------------------------------\\n # Check for unit validity \\n #-----------------------------------------------------------------\\n\\n if unit != acuUnit.getBaseUnit( toUnit ):\\n raise AcuDbAssistError, \\\"Invalid unit argument to get adbValues.\\\"\\n \\n #-----------------------------------------------------------------\\n # Convert base unit to given unit\\n #-----------------------------------------------------------------\\n\\n return self.cnvValues( values, unit, toUnit )\",\n \"def to_unit_validator(compatible_units):\\n def _to_unit_validator(quantity_str):\\n return process_unit_bearing_str(quantity_str, compatible_units)\\n return _to_unit_validator\",\n \"def convert_units(array, in_units=\\\"None\\\"):\\n if in_units == \\\"None\\\" or in_units is None:\\n return array\\n else:\\n raise Exception(\\\"Unsupported unit for bispectrum descriptors.\\\")\",\n \"def convertToSI(*args):\\n return _libsbml.UnitDefinition_convertToSI(*args)\",\n \"def unit(x,convert_to=\\\"px\\\",from_unit=\\\"px\\\"):\\n assert convert_to in UNITS, \\\"Cannot convert to unknown unit: %s\\\" % convert_to\\n assert from_unit in UNITS, \\\"Cannot from unknown unit: %s\\\" % from_unit\\n return float(x)*UNITS[convert_to]/UNITS[from_unit]\",\n \"def get_units(self):\\r\\n msg = struct.pack('>2B', 56, 14)\\r\\n response = self.query(msg)\\r\\n\\r\\n if response[1] == 2:\\r\\n units = 'A'\\r\\n to_nm_multiplier = 1 / 10\\r\\n elif response[1] == 1:\\r\\n units = 'nm'\\r\\n to_nm_multiplier = 1\\r\\n elif response[1] == 0:\\r\\n units = 'um'\\r\\n to_nm_multiplier = 1000\\r\\n else:\\r\\n raise ValueError('Units not recognised.')\\r\\n\\r\\n # Save results locally too for quick re-use\\r\\n self._current_units = units\\r\\n self._current_to_nm_multiplier = to_nm_multiplier\\r\\n\\r\\n return units, to_nm_multiplier\",\n \"def convertUnits(self, varname, arr):\\n if varname == \\\"SPDQ\\\" or varname == \\\"PHQ\\\":\\n return arr*2.5e6/1000.\\n return arr\",\n \"def get_unit(shared, unit_name):\\n if (shared.config.get_safe('data', 'use_units') != 'off'):\\n unit_val, unit_str = shared.config.get_safe_literal('units', unit_name,\\n default=(1.0, ''))\\n if unit_str:\\n unit_str = ' [' + unit_str + ']'\\n else:\\n unit_val = 1.0\\n unit_str = ''\\n \\n return unit_val, unit_str\",\n \"def tranfer_unit(number):\\n count = 0\\n unit_name = \\\"\\\"\\n if 2 ** 20 > number > 2 ** 10:\\n unit_name = \\\"Kb\\\"\\n count = 1\\n elif 2 ** 30 > number > 2 ** 20:\\n unit_name = \\\"Mb\\\"\\n count = 2\\n elif number > 2 ** 30:\\n unit_name = \\\"Gb\\\"\\n count = 3\\n else:\\n unit_name = \\\"b\\\"\\n if count != 0:\\n unit_number = round(number / ((2 ** 10) ** count), 2)\\n else:\\n unit_number = round(number, 2)\\n unit_str = \\\"{num}{name}\\\".format(num=unit_number, name=unit_name)\\n return unit_str\",\n \"def _convert_value(self, value, unit, axis):\\n if hasattr(value, 'units'):\\n return value.to(unit).magnitude\\n else:\\n return self._reg.Quantity(value, axis.get_units()).to(unit).magnitude\",\n \"def tempConvert(temp, unit):\\n if unit == 'F':\\n celsius = (temp - 32) * 5 / 9\\n return celsius\\n else:\\n return temp\",\n \"def _add_converted_units(self, dataframe, parameter, key='VALUE'):\\n convert_unit = self.parameters.get_converter(parameter)\\n try:\\n dataframe[key] = dataframe['DATA_VALUE'].apply(convert_unit)\\n except KeyError:\\n log.warn(\\\"Missing 'VALUE': no unit conversion.\\\")\\n else:\\n dataframe.unit = self.parameters.unit(parameter)\",\n \"def test_change_units(self):\\n s = State(\\\"water\\\", T=Q_(100, \\\"degC\\\"), p=Q_(1.0, \\\"atm\\\"), units=\\\"EE\\\")\\n assert s.units == \\\"EE\\\"\\n s.units = \\\"SI\\\"\\n assert s.units == \\\"SI\\\"\\n assert s.cv.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.cp.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.s.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.h.units == \\\"kilojoule / kilogram\\\"\\n assert s.T.units == \\\"degree_Celsius\\\"\\n assert s.u.units == \\\"kilojoule / kilogram\\\"\\n assert s.v.units == \\\"meter ** 3 / kilogram\\\"\\n assert s.p.units == \\\"bar\\\"\",\n \"def test_convert_unit_bad_args(test_pd_df):\\n idf = IamDataFrame(test_pd_df).rename(unit={\\\"EJ/yr\\\": \\\"Mt CH4\\\"})\\n\\n # Conversion fails with both *factor* and *registry*\\n with pytest.raises(ValueError, match=\\\"Use either `factor` or `registry`!\\\"):\\n idf.convert_unit(\\\"Mt CH4\\\", \\\"CO2e\\\", factor=1.0, registry=object())\\n\\n # Conversion fails with an invalid registry\\n with pytest.raises(TypeError, match=\\\"must be `pint.UnitRegistry`\\\"):\\n idf.convert_unit(\\\"Mt CH4\\\", \\\"CO2e\\\", registry=object())\\n\\n # Conversion fails without context; exception provides a usage hint\\n match = r\\\"GWP conversion with IamDataFrame.convert_unit\\\\(\\\\) requires...\\\"\\n with pytest.raises(pint.UndefinedUnitError, match=match):\\n idf.convert_unit(\\\"Mt CH4\\\", \\\"CO2e\\\")\",\n \"def _to(\\n value: Union[\\\"Value\\\", \\\"ValueArray\\\"], units: Union[Unit, str], inplace: bool\\n) -> Any:\\n if value.units == units:\\n return value\\n\\n if value.units is None:\\n raise RuntimeError(\\\"Cannot convert with units=None\\\")\\n\\n try:\\n units = next(\\n imp_unit\\n for imp_unit in value.implemented_units\\n if units.lower() in imp_unit.aliases\\n )\\n\\n except StopIteration:\\n raise TypeError(\\n f\\\"No viable unit conversion from {value.units} -> {units}\\\"\\n )\\n\\n if not (isinstance(value, Value) or isinstance(value, ValueArray)):\\n raise ValueError(\\n f\\\"Cannot convert {value} to new units. Must be one of\\\"\\n f\\\" Value of ValueArray\\\"\\n )\\n\\n if isinstance(value, Value) and inplace:\\n raise ValueError(\\n \\\"Cannot modify a value inplace as floats are immutable\\\"\\n )\\n\\n # Convert to the base unit, then to the new units\\n c = float(units.conversion / value.units.conversion)\\n\\n new_value = value if inplace else value.copy()\\n new_value *= c\\n new_value.units = units\\n\\n return None if inplace else new_value\",\n \"def _parse_units(self, model, comp, node):\\n node = dom_child(node, 'unitDefinition')\\n while node:\\n name = node.getAttribute('id')\\n self.log('Parsing unit definition for \\\"' + name + '\\\".')\\n unit = myokit.units.dimensionless\\n node2 = dom_child(node, 'listOfUnits')\\n node2 = dom_child(node2, 'unit')\\n while node2:\\n kind = str(node2.getAttribute('kind')).strip()\\n u2 = self._convert_unit(kind)\\n if node2.hasAttribute('multiplier'):\\n m = float(node2.getAttribute('multiplier'))\\n else:\\n m = 1.0\\n if node2.hasAttribute('scale'):\\n m *= 10 ** float(node2.getAttribute('scale'))\\n u2 *= m\\n if node2.hasAttribute('exponent'):\\n u2 **= float(node2.getAttribute('exponent'))\\n unit *= u2\\n node2 = dom_next(node2, 'unit')\\n self.units[name] = unit\\n node = dom_next(node, 'unitDefinition')\",\n \"def test_unit_conversion_incompatible(self):\\n self.orography_cube.units = 'K'\\n msg = \\\"Unable to convert from\\\"\\n with self.assertRaisesRegex(ValueError, msg):\\n self.plugin_instance.process(self.orography_cube)\",\n \"def convert_volume(self, event):\\n try:\\n #Compare other unit to one unit(cubic decimeters)\\n current_value, current_unit = float(\\\"0\\\" + str(self.v.get())), self.dropdown.get()\\n unit_comp = {\\\"acre foot\\\": 1233481.837548, \\\"barrels\\\": 158.987295, \\\"bushels(UK)\\\": 36.36872, \\\"bushels(US)\\\": 35.23907, \\\"centiliters\\\": 0.01, \\\"cubic centimeters\\\": 0.001, \\\"cubic decameters\\\": 1000000.0, \\\"cubic decimeters\\\": 1.0, \\\"cubic feet\\\": 28.316847, \\\"cubic inches\\\": 0.016387, \\\"cubic kilometers\\\": 1000000000000.0, \\\"cubic meters\\\": 1000.0, \\\"cubic mile\\\": 4168181825000.0, \\\"cubic millimeters\\\": 1e-06, \\\"cubic yards\\\": 764.554858, \\\"cups\\\": 0.236588, \\\"deciliters\\\": 0.1, \\\"dram\\\": 0.003697, \\\"dram(imperial)\\\": 0.003552, \\\"fluid ounces(US)\\\": 0.029574, \\\"fluid ounces(imperial)\\\": 0.028413, \\\"gallons(US,dry)\\\": 4.404884, \\\"gallons(US,liquid)\\\": 3.785412, \\\"gallons(imperial)\\\": 4.54609, \\\"gill(US)\\\": 0.118294, \\\"gill(imperial)\\\": 0.142065, \\\"liters\\\": 1.0, \\\"liters(1901-1964)\\\": 1.000028, \\\"microliters\\\": 1e-06, \\\"milliliters\\\": 0.001, \\\"nanoliters\\\": 1e-09, \\\"picoliters\\\": 1e-12, \\\"pints(US,dry)\\\": 0.55061, \\\"pints(US,liquid)\\\": 0.473176, \\\"pints(imperial)\\\": 0.568261, \\\"quarts(UK,dry)\\\": 1.101221, \\\"quarts(US,liquid)\\\": 0.946353, \\\"quarts(imperial)\\\": 1.136523, \\\"table spoons\\\": 0.014787, \\\"tea spoons\\\": 0.004929}\\n value_comp, printer = current_value * unit_comp[current_unit], \\\"\\\"\\n unit_list = sorted(unit_comp.keys())\\n unit_list.remove(current_unit)\\n for unit in unit_list:\\n printer += \\\"To %s \\\" % unit + \\\" \\\" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\\\"\\\", \\\"\\\\n\\\"][unit_list[-1] != unit]\\n except ValueError: #In case user enter the other type of value, not Int or Float\\n printer = \\\"Value is invalid.\\\"\\n self.print_text(printer)\",\n \"def add_special_conversion(self, from_units, to_units, converter):\\n self.special_conversions[(from_units, to_units)] = converter\",\n \"def get_unit_registry():\\n\\n global _unit_registry\\n\\n # Cache the unit registry for speedier access\\n if _unit_registry is None:\\n return reload_unit_registry()\\n else:\\n return _unit_registry\",\n \"def convert(value, unit, axis):\\n converted_value = value\\n if isinstance(unit, str) or isinstance(unit, Unit):\\n unit = (unit,)\\n if isinstance(value, (unyt_array, unyt_quantity)):\\n converted_value = value.to(*unit)\\n else:\\n value_type = type(value)\\n converted_value = []\\n for obj in value:\\n converted_value.append(obj.to(*unit))\\n converted_value = value_type(converted_value)\\n return converted_value\",\n \"def _to_lems_unit(unit):\\n if type(unit) == str:\\n strunit = unit\\n else:\\n strunit = unit.in_best_unit()\\n strunit = strunit[3:] # here we substract '1. '\\n strunit = strunit.replace('^', '') # in LEMS there is no ^\\n return strunit\",\n \"def _override_units_system(self):\\n try:\\n f = open(self.filename+\\\".units\\\")\\n except OSError:\\n return\\n\\n name_mapping = {'pos': 'distance', 'vel': 'velocity'}\\n units_dict = {}\\n\\n for line in f:\\n if (not line.startswith(\\\"#\\\")):\\n if \\\":\\\" not in line:\\n raise OSError(\\\"Unknown format for units file %r\\\"%(self.filename+\\\".units\\\"))\\n else:\\n t, u = list(map(str.strip,line.split(\\\":\\\")))\\n t = name_mapping.get(t,t)\\n units_dict[t] = u\\n\\n self.set_units_system(**units_dict)\",\n \"def to(self, unit, equivalencies=[], freq=None):\\n\\n if not isinstance(unit, u.Unit):\\n unit = u.Unit(unit)\\n\\n if unit == self.unit:\\n # No copying\\n return self\\n\\n if ((self.unit.is_equivalent(u.Jy / u.beam) and\\n not any({u.Jy/u.beam, u.K}.issubset(set(eq)) for eq in equivalencies))):\\n # the 'not any' above checks that there is not already a defined\\n # Jy<->K equivalency. If there is, the code below is redundant\\n # and will cause problems.\\n\\n if hasattr(self, 'beams'):\\n factor = (self.jtok_factors(equivalencies=equivalencies) *\\n (self.unit*u.beam).to(u.Jy))\\n else:\\n # replace \\\"beam\\\" with the actual beam\\n if not hasattr(self, 'beam'):\\n raise ValueError(\\\"To convert objects with Jy/beam units, \\\"\\n \\\"the object needs to have a beam defined.\\\")\\n brightness_unit = self.unit * u.beam\\n\\n # create a beam equivalency for brightness temperature\\n if freq is None:\\n try:\\n freq = self.with_spectral_unit(u.Hz).spectral_axis\\n except AttributeError:\\n raise TypeError(\\\"Object of type {0} has no spectral \\\"\\n \\\"information. `freq` must be provided for\\\"\\n \\\" unit conversion from Jy/beam\\\"\\n .format(type(self)))\\n else:\\n if not freq.unit.is_equivalent(u.Hz):\\n raise u.UnitsError(\\\"freq must be given in equivalent \\\"\\n \\\"frequency units.\\\")\\n\\n bmequiv = self.beam.jtok_equiv(freq)\\n # backport to handle astropy < 3: the beam equivalency was only\\n # modified to handle jy/beam in astropy 3\\n if bmequiv[0] == u.Jy:\\n bmequiv.append([u.Jy/u.beam, u.K, bmequiv[2], bmequiv[3]])\\n\\n factor = brightness_unit.to(unit,\\n equivalencies=bmequiv + list(equivalencies))\\n\\n else:\\n # scaling factor\\n factor = self.unit.to(unit, equivalencies=equivalencies)\\n\\n converted_array = (self.quantity * factor).value\\n\\n # use private versions of variables, not the generated property\\n # versions\\n # Not entirely sure the use of __class__ here is kosher, but we do want\\n # self.__class__, not super()\\n new = self.__class__(value=converted_array, unit=unit, copy=True,\\n wcs=self._wcs, meta=self._meta, mask=self._mask,\\n header=self._header)\\n\\n return new\",\n \"def set_units(self, units):\\n self.units = units\",\n \"def unit_conversion(thing, units, length=False):\\n if 'n/a' == thing:\\n return 'n/a'\\n try:\\n thing = round(thing * CONVERSION[units][0 + length], 2)\\n except:\\n thing = 'fubar'\\n return thing, CONVERSION[units][2 + length]\",\n \"def process_unit_input(in_,\\n default_units: UnitLike = None,\\n convert: bool = False,\\n check_dims: bool = False,\\n copy: bool = True,\\n registry: unyt.UnitRegistry = None) -> unyt_array:\\n parser = UnitInputParser(default_units=default_units,\\n convert=convert,\\n check_dims=check_dims,\\n copy=copy,\\n registry=registry)\\n return parser.parse(in_)\",\n \"def units(self, *args):\\n u = self.parent.unit\\n return tuple('%s%s' % (a, u) for a in args)\",\n \"def test_unit_conversion_compatible(self):\\n self.orography_cube.convert_units('ft')\\n probability_cube = self.plugin_instance.process(self.orography_cube)\\n self.assertIsInstance(probability_cube, iris.cube.Cube)\\n self.assertSequenceEqual(probability_cube.shape,\\n self.reference_cube.shape)\",\n \"def init():\\n return _libsbml.SBMLInferUnitsConverter_init()\",\n \"def to(self, unit, equivalencies=[]):\\n\\n return super(BaseOneDSpectrum, self).to(unit, equivalencies, freq=None)\",\n \"def unit_type(self) -> str:\",\n \"def __init__(self, *args):\\n this = _libsbml.new_SBMLUnitsConverter(*args)\\n try: self.this.append(this)\\n except: self.this = this\",\n \"def get_units(self,):\\n self.UNITS = {'pressure':'Pa',}\\n return\",\n \"def conv(old='auto', new='auto'):\\n if old == new:\\n return 1.\\n for unittype in [lenunits, angunits, timunits, masunits, eneunits]:\\n if old in unittype and new in unittype:\\n return unittype[new] / unittype[old]\\n\\n raise ValueError('Units \\\\'{}\\\\' and \\\\'{}\\\\' unrecognized or '\\n 'not of same unit type'.format(old, new))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72558576","0.7242834","0.69972605","0.67883354","0.6740144","0.6727505","0.6723467","0.67014116","0.66655236","0.6658775","0.6603207","0.65299666","0.64555025","0.64369696","0.6419799","0.64174867","0.64120305","0.6399249","0.63895","0.6342039","0.6332659","0.628787","0.62832105","0.62518567","0.6233634","0.62296045","0.6228601","0.62142986","0.61970496","0.61949044","0.6191631","0.6170725","0.61693746","0.61676055","0.6165592","0.616516","0.61370677","0.6132448","0.60983086","0.6078547","0.6078447","0.6077847","0.6043941","0.6032828","0.6017621","0.6014453","0.6011454","0.6011008","0.5977763","0.59692276","0.5921444","0.5921405","0.59131193","0.59081835","0.58699983","0.58458203","0.58424103","0.58212036","0.58161867","0.5800563","0.5792476","0.5784152","0.5780839","0.57805765","0.5780138","0.5780067","0.57733214","0.57531196","0.5752863","0.57499635","0.5735281","0.5733068","0.57207286","0.571761","0.5716809","0.5709201","0.5708238","0.5707577","0.5703748","0.57010394","0.569472","0.56941336","0.5693189","0.56908715","0.56738436","0.567189","0.5671395","0.56713414","0.56524646","0.5652377","0.5640453","0.5638179","0.5635824","0.5629819","0.56242764","0.5619494","0.5607684","0.5607023","0.56047463","0.55981696"],"string":"[\n \"0.72558576\",\n \"0.7242834\",\n \"0.69972605\",\n \"0.67883354\",\n \"0.6740144\",\n \"0.6727505\",\n \"0.6723467\",\n \"0.67014116\",\n \"0.66655236\",\n \"0.6658775\",\n \"0.6603207\",\n \"0.65299666\",\n \"0.64555025\",\n \"0.64369696\",\n \"0.6419799\",\n \"0.64174867\",\n \"0.64120305\",\n \"0.6399249\",\n \"0.63895\",\n \"0.6342039\",\n \"0.6332659\",\n \"0.628787\",\n \"0.62832105\",\n \"0.62518567\",\n \"0.6233634\",\n \"0.62296045\",\n \"0.6228601\",\n \"0.62142986\",\n \"0.61970496\",\n \"0.61949044\",\n \"0.6191631\",\n \"0.6170725\",\n \"0.61693746\",\n \"0.61676055\",\n \"0.6165592\",\n \"0.616516\",\n \"0.61370677\",\n \"0.6132448\",\n \"0.60983086\",\n \"0.6078547\",\n \"0.6078447\",\n \"0.6077847\",\n \"0.6043941\",\n \"0.6032828\",\n \"0.6017621\",\n \"0.6014453\",\n \"0.6011454\",\n \"0.6011008\",\n \"0.5977763\",\n \"0.59692276\",\n \"0.5921444\",\n \"0.5921405\",\n \"0.59131193\",\n \"0.59081835\",\n \"0.58699983\",\n \"0.58458203\",\n \"0.58424103\",\n \"0.58212036\",\n \"0.58161867\",\n \"0.5800563\",\n \"0.5792476\",\n \"0.5784152\",\n \"0.5780839\",\n \"0.57805765\",\n \"0.5780138\",\n \"0.5780067\",\n \"0.57733214\",\n \"0.57531196\",\n \"0.5752863\",\n \"0.57499635\",\n \"0.5735281\",\n \"0.5733068\",\n \"0.57207286\",\n \"0.571761\",\n \"0.5716809\",\n \"0.5709201\",\n \"0.5708238\",\n \"0.5707577\",\n \"0.5703748\",\n \"0.57010394\",\n \"0.569472\",\n \"0.56941336\",\n \"0.5693189\",\n \"0.56908715\",\n \"0.56738436\",\n \"0.567189\",\n \"0.5671395\",\n \"0.56713414\",\n \"0.56524646\",\n \"0.5652377\",\n \"0.5640453\",\n \"0.5638179\",\n \"0.5635824\",\n \"0.5629819\",\n \"0.56242764\",\n \"0.5619494\",\n \"0.5607684\",\n \"0.5607023\",\n \"0.56047463\",\n \"0.55981696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72553796"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14870,"cells":{"query":{"kind":"string","value":"Units and GHG species can be converted."},"document":{"kind":"string","value":"def test_convert_gwp(\n test_df, context, current_species, current_expr, to_expr, exp, exp_factor\n):\n # Handle parameters\n current = current_expr.format(current_species)\n to = to_expr.format(\"CO2e\")\n\n # Expected values\n exp_values = test_df._data.copy()\n exp_values[[False, False, True, True, True, True]] *= exp * exp_factor\n\n # Prepare test data and assert cenverted units\n df = get_units_test_df(test_df).rename(unit={\"EJ/yr\": current})\n assert_converted_units(df.copy(), current, to, exp_values, context=context)"},"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 convert_to(self, units: str) -> None:\n if self.units == units:\n return\n\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\n msg = f\"\"\"Not a valid unit conversion. Valid destination units:\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\"\"\"\n raise ValueError(msg)\n\n if self.units == \"celsius\" and units == \"fahrenheit\":\n self._celsius_to_fahrenheit()\n elif self.units == \"m/s\" and units == \"km/h\":\n self._mps_to_kph()\n elif self.units == \"m/s\" and units == \"mph\":\n self._mps_to_mph()\n else:\n raise ValueError(\"Not a valid unit conversion.\")","def convertToSpectroGram(self):","def test_convert(self):\n height = 1.6 * self.meter\n foot = .305 * self.meter\n inch = 1 / 12 * foot\n\n self.assertTrue(abs(height / foot - 5.246) < .001)\n self.assertTrue(abs(height / inch - 62.951) < .001)\n\n newton = self.kgram * self.meter / (self.second ** 2)\n pound = 4.448222 * newton\n accel = 9.8 * self.meter / (self.second ** 2)\n\n weight = 150 * pound\n mass = weight / accel\n self.assertTrue(abs(mass / self.kgram - 68.085) < .001)","def useUnits():","def convert_mass(self, event):\n try:\n #Compare other unit to one unit(kilograms)\n current_value, current_unit = float(\"0\" + str(self.v.get())), self.dropdown.get()\n unit_comp = {\"Earth masses\": 5.97219e+24, \"Solar masses\": 1.9890000000000002e+30, \"carats\": 0.0002, \"cental\": 45.359237, \"decagrams\": 0.01, \"femtograms\": 1e-18, \"grains\": 6.479891000000001e-05, \"grams\": 0.001, \"hectograms\": 0.1, \"hundredweights\": 50.802345, \"kilograms\": 1.0, \"kilotonnes\": 1000000.0, \"megatonnes\": 1000000000.0, \"micrograms\": 1e-09, \"milligrams\": 1e-06, \"nanograms\": 1e-12, \"ounces(US & UK)\": 0.02835, \"ounces(precious metals)\": 0.031103, \"picograms\": 1e-15, \"pounds(US & UK)\": 0.453592, \"pounds(precious metals)\": 0.373242, \"slugs\": 14.593903, \"stones\": 6.350293, \"tonnes(metric)\": 1000.0, \"tons(UK)\": 1016.046909, \"tons(US)\": 907.18474}\n value_comp, printer = current_value * unit_comp[current_unit], \"\"\n unit_list = sorted(unit_comp.keys())\n unit_list.remove(current_unit)\n for unit in unit_list:\n printer += \"To %s \" % unit + \" \" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\"\", \"\\n\"][unit_list[-1] != unit]\n except ValueError: #In case user enter the other type of value, not Int or Float\n printer = \"Value is invalid.\"\n self.print_text(printer)","def test_convert_compatible_units(self):\n result = convert_units(self.arr, 'degC')\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\n expected_units = cf_units.Unit('degC')\n self.assertEquals(result.units, expected_units)\n self.assertArrayEqual(result.data, expected_data)","def latin_to_genus_species(self, latin_name):\n # Default #\n genus_name = 'missing'\n species_name = 'missing'\n # Lower case the input #\n latin_name = latin_name.lower()\n # Split into words #\n words = latin_name.split()\n # Get all possible genera #\n genera = self.known_species['genus'].unique().tolist()\n # Compare against all possible genera, take first match #\n for word in words:\n if genus_name != 'missing': break\n for genus in genera:\n if genus_name != 'missing': break\n if word == genus: genus_name = genus\n # Get all possible species #\n all_species = self.known_species.query(\"genus==@genus_name\")\n all_species = all_species['species'].unique().tolist()\n # Compare against all possible species, take first match #\n for word in words:\n if species_name != 'missing': break\n for species in all_species:\n if species_name != 'missing': break\n if word == species: species_name = species\n # Return #\n return genus_name, species_name","def test_convert_same_unit():\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5","def convert_units(data, units):\n # Build the dictionary of units conversions\n convert = {'m' : [1.0, 0., 'm'], \n 'meter' : [1.0, 0., 'm'], \n 'deg C' : [1.0, 273.15, 'K'], \n 'Celsius' : [1.0, 273.15, 'K'], \n 'K' : [1.0, 0., 'K'],\n 'db' : [1.e4, 101325., 'Pa'], \n 'Pa' : [1.0, 0., 'Pa'],\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \n 'S/m': [1.0, 0., 'S/m'],\n 'mS/m' : [1.e-3, 0., 'S/m'],\n 'psu': [1.0, 0., 'psu'], \n 'salinity': [1.0, 0., 'psu'], \n 'kg/m^3': [1.0, 0., 'kg/m^3'], \n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \n 'm/s': [1.0, 0., 'm/s'], \n 'mg/l': [1.e-3, 0., 'kg/m^3'],\n 'meter second-1' : [1.0, 0., 'm/s'],\n 'm.s-1' : [1.0, 0., 'm/s'],\n 'pH units' : [1.0, 0., 'pH units'],\n 'MPa' : [1.e6, 0., 'Pa'],\n '--' : [1.0, 0., '--'],\n 'mD' : [9.869233e-16, 0., 'm^2'],\n 'um' : [1.e-6, 0., 'm'],\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\n 'wt.%' : [10., 0., 'psu'],\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\n 'm^2' : [1., 0., 'm^2'],\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \n } \n \n # Make sure the data are a numpy array and the units are a list\n if isinstance(data, float) or isinstance(data, int):\n data = np.array([data])\n if isinstance(data, list):\n data = np.array(data)\n if isinstance(units, str) or isinstance(units, unicode):\n units = [units]\n if units == None:\n units = ['']\n \n # Make sure you can slice through the columns: must be two-dimensional\n sh = data.shape\n data = np.atleast_2d(data)\n \n # Allow conversion of a row of data if all of the same unit\n if len(units) == 1 and data.shape[1] > 1:\n data = data.transpose()\n \n # Create an emtpy array to hold the output\n out_data = np.zeros(data.shape)\n out_units = []\n \n # Convert the units\n for i in range(len(units)):\n try:\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\n convert[units[i]][1]\n out_units += [convert[units[i]][2]]\n except KeyError:\n print('Do not know how to convert %s to mks units' % units[i])\n print('Continuing without converting these units...')\n out_data[:,i] = data[:,i]\n out_units += units[i]\n \n # Return the converted data in the original shape\n out_data = np.reshape(out_data, sh, 'C')\n return (out_data, out_units)","def test_species(self):\n spec = input.species('C2H4', os.path.join(self.directory, 'species', 'C2H4', 'ethene.py'))\n self.assertTrue(isinstance(spec, Species))\n self.assertEqual(len(spec.molecule), 0)","def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6","def test_conversion(self):\n r = self.RNA(\"TCAtu\")\n self.assertEqual(str(r), \"UCAUU\")\n\n d = self.DNA(\"UCAtu\")\n self.assertEqual(str(d), \"TCATT\")","def describe_a_library_of_units_converters_that():\n def blows_smoke():\n assert True\n\n def can_convert_psi_to_kpa():\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\n\n # def can_convert_kpa_to_psi():\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\n\n # def can_convert_mpg_to_lp100k():\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\n\n # def can_convert_lp100k_to_mpg():\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg","def convertUnits(self, varname, arr):\n if varname == \"SPDQ\" or varname == \"PHQ\":\n return arr*2.5e6/1000.\n return arr","def test_hartree_to_si(self):\n e = converter.hartree_to_si(1)\n self.assertAlmostEqual(e, 2625.5, places=1)\n e = converter.hartree_to_si(5)\n self.assertAlmostEqual(e, 13127.499291814986)\n e = converter.hartree_to_si(5, kilo=False)\n self.assertAlmostEqual(e, 13127499.291814985)\n e = converter.hartree_to_si(-10.752192838993)\n self.assertAlmostEqual(e, -28229.880775867754)","def _check_special_conversion(self, expr):\n lhs_units = expr.eq.lhs.get_units()\n rhs_units = expr.eq.rhs.get_units()\n if lhs_units.dimensionally_equivalent(rhs_units):\n return\n for from_units, to_units in self.special_conversions.iterkeys():\n if (from_units.dimensionally_equivalent(rhs_units)\n and to_units.dimensionally_equivalent(lhs_units)):\n # We can apply this conversion\n self.special_conversions[(from_units, to_units)](expr)\n DEBUG('units-converter', \"Used special conversion from\", repr(from_units), \"to\", repr(to_units))#, \"giving\", expr.xml())\n break","def testSpeciesRichnessValuesAsExpected(self):\n self.assertEqual(69, self.tree.get_species_richness(1))\n self.assertEqual(69, self.tree.get_species_richness(2))\n self.assertEqual(69, self.tree.get_species_richness(3))\n self.assertEqual(22, self.tree.get_species_richness(4))\n self.assertEqual(19, self.tree.get_species_richness(5))\n self.assertEqual(25, self.tree.get_species_richness(6))","def convert_F_units(F, lbda, in_unit='cgs', out_unit='si'):\n\n if in_unit == 'cgs':\n new_F = (F*1e23*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == 'cgsA':\n new_F = (F*1e27*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == 'si':\n new_F = (F*1e26*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == \"jy\":\n new_F=F\n else:\n msg = \"in_unit not recognized, try either 'cgs', 'si' or 'jy'.\"\n raise TypeError(msg) \n if out_unit == 'jy':\n return new_F\n elif out_unit == 'cgs':\n return new_F*1e-23*c.c.value*1e6/np.power(lbda,2)\n elif out_unit == 'si':\n return new_F*1e-26*c.c.value*1e6/np.power(lbda,2)\n else:\n msg = \"out_unit not recognized, try either 'cgs', 'si' or 'jy'.\"\n raise TypeError(msg)","def testNSESanityChecks(self):\n self.assertEqual(100, self.c.get_species_richness())\n self.assertEqual(67, self.c2.get_species_richness())","def test_unit_conversion_compatible(self):\n self.orography_cube.convert_units('ft')\n probability_cube = self.plugin_instance.process(self.orography_cube)\n self.assertIsInstance(probability_cube, iris.cube.Cube)\n self.assertSequenceEqual(probability_cube.shape,\n self.reference_cube.shape)","def convert_units(data, hdr, conv_to = \"surf_br\"):\n \n data_unit = hdr[\"SIGUNIT\"]\n \n if \"Jy/pix\" in data_unit:\n # pixel size in rad\n px_x = abs(hdr[\"CDELT1\"])*2*np.pi/360\n px_y = abs(hdr[\"CDELT2\"])*2*np.pi/360\n \n #pixel size in arcsec\n \n px_x = abs(hdr[\"CDELT1\"])*3600\n px_y = abs(hdr[\"CDELT2\"])*3600\n conversion_factor = 1000/(px_x*px_y)\n \n unit_label = \"mJy/arcsec^2\"\n \n #in case we want to convert to units flux, we need to multiply by the size (in steradians) of a pixel.\n if conv_to == \"flux\":\n conversion_factor*=abs(hdr[\"CDELT1\"])*abs(hdr[\"CDELT2\"])*(2*np.pi/360)**2\n unit_label = \"mJy\"\n \n data *= conversion_factor\n hdr[\"SIGUNIT\"] = unit_label\n else:\n print(\"\\t[WARNING]\\t \"+data_unit+\" conversion not yet implemented. No conversion performed.\")\n \n return data, hdr","def convert_units(self, units):\n self.unit_array = self.unit_array.to(units)","def convert_same_units(self):\n # Convert pumping rate data\n pump_units = \"%s3/%s\" % (self.len_units, self.time_units)\n flag = _units.validate_units(pump_units)\n if flag == 2:\n self.pumprate.convert_units(self.time_units, pump_units)\n self.pump_units = pump_units","def preprocess_sub_units(self):\n if self.unit == \"char\":\n self.preprocess_char()\n elif self.unit == \"char-ngram\":\n self.preprocess_char_ngram()\n elif self.unit == \"morpheme\":\n self.preprocess_morpheme()\n elif self.unit == \"oracle\":\n self.preprocess_oracle()\n else:\n sys.exit(\"Unknown unit\")","def convert_energy(self, event):\n try:\n #Compare other unit to one unit(joules)\n current_value, current_unit = float(\"0\" + str(self.v.get())), self.dropdown.get()\n unit_comp = {\"Btu(th)\": 1054.35, \"Btu(mean)\": 1055.87, \"calories(IT)\": 4.1868, \"calories(th)\": 4.184, \"calories(mean)\": 4.19002, \"calories(15C)\": 4.1858, \"calories(20C)\": 4.1819, \"calories(food)\": 4186.0, \"centigrade heat units\": 1900.4, \"electron volts\": 1.60219 * 10 ** -19, \"ergs\": 1.0 * 10 ** -7, \"foot-pound force\": 1.355818, \"foot poundals\": 0.04214, \"gigajoules\": 1.0 * 10 ** 9, \"horsepower hours\": 2684520.0, \"inch-pound force\": 0.112985, \"joules\": 1.0, \"kilocalories(IT)\": 4186.8, \"kilocalories(th)\": 4184.0, \"kilogram-force meters\": 9.80665, \"kilojoules\": 1000.0, \"kilowatt hours\": 3600000.0, \"megajoules\": 1.0 * 10 ** 6, \"newton meters\": 1.0, \"therms\": 105505585.257348, \"watt seconds\": 1.0, \"watt hours\" : 3600.0}\n value_comp, printer = current_value * unit_comp[current_unit], \"\"\n unit_list = sorted(unit_comp.keys())\n unit_list.remove(current_unit)\n for unit in unit_list:\n printer += \"To %s \" % unit + \" \" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\"\", \"\\n\"][unit_list[-1] != unit]\n except ValueError: #In case user enter the other type of value, not Int or Float\n printer = \"Value is invalid.\"\n self.print_text(printer)","def convert_units(unt, origunits):\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\n units = origunits\n convf = 1\n else:\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'met':\n units = 'feet'\n convf = 3.2808399\n else:\n units = origunits\n convf = 1\n else:\n if 'met' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'fee':\n units = 'meters'\n convf = 0.3048\n else:\n units = origunits\n convf = 1\n else:\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'kno':\n units = 'meters/sec'\n convf = 0.51444444\n else:\n units = origunits\n convf = 1\n else:\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'm/s':\n units = 'knots'\n convf = 1.9438445\n else:\n units = origunits\n convf = 1\n else:\n error('Unknown units')\n #\n return units, convf","def getUnits(self):\n return _libsbml.Species_getUnits(self)","def setUnits(self, *args):\n return _libsbml.Species_setUnits(self, *args)","def test_convert_nonnumeric_value():\n with pytest.raises(TypeError):\n pressure_util.convert(\"a\", PRESSURE_HPA, PRESSURE_INHG)","def test_set_us(self):\n s = State(substance=\"water\")\n s.us = Q_(1013250.0, \"J/kg\"), Q_(3028.9867985920914, \"J/(kg*K)\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.us[0], Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.us[1], Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore","def convert_F_vs_mag(value, F_0=None, band='H', system='Johnson', \n conversion='to_mag'): \n \n dico_zero_pts_Jo = {'U': [0.36,1823.],\n 'B': [0.44,4130.],\n 'V': [0.55,3781.],\n 'R': [0.71,2941.],\n 'I': [0.97,2635.],\n 'J': [1.25,1603.],\n 'H': [1.60,1075.],\n 'K': [2.22,667.],\n 'L': [3.54,288.],\n 'M': [4.80,170.],\n 'N': [10.6,36.],\n 'O': [21.0,9.4]}\n dico_zero_pts_2M = {'J': [1.235,1594.],\n 'H': [1.662,1024.],\n 'K': [2.159,666.7]}\n dico_zero_pts_UK = {'V': [0.5556,3540.], # TOKUNAGA (from Cohen 1992)\n 'I': [0.9,2250.], # UKIRT webpage\n 'J': [1.215,1630.], # TOKUNAGA (from Cohen 1992)\n 'H': [1.654,1050.], # TOKUNAGA (from Cohen 1992)\n 'Ks': [2.157,667.], # TOKUNAGA (from Cohen 1992)\n 'K': [2.179,655.], # TOKUNAGA (from Cohen 1992) \n 'L': [3.547,276.], # TOKUNAGA (from Cohen 1992) \n \"L'\": [3.761,248.], # TOKUNAGA (from Cohen 1992) \n 'M': [4.769,160.], # TOKUNAGA (from Cohen 1992) \n '8.7': [8.756,50.], # TOKUNAGA (from Cohen 1992) \n 'N': [10.472,35.3], # TOKUNAGA (from Cohen 1992) \n '11.7': [11.653,28.6], # TOKUNAGA (from Cohen 1992) \n 'Q': [20.13,9.7]} # TOKUNAGA (from Cohen 1992)\n dico_zero_pts_ESO = {'J': [1.228,3.44e-9], # van der Bliek 1996\n 'H': [1.651,1.21e-9], # van der Bliek 1996\n 'K': [2.216,4.12e-10], # van der Bliek 1996\n \"L'\": [3.771,5.58e-11], # van der Bliek 1996\n \"M\": [4.772,2.21e-11]} # van der Bliek 1996 \n \n if F_0 is None:\n if system == 'Johnson' and band in dico_zero_pts_Jo:\n dico_F_0 = dico_zero_pts_Jo\n elif system == '2MASS' and band in dico_zero_pts_2M:\n dico_F_0 = dico_zero_pts_2M\n elif system == 'UKIRT' and band in dico_zero_pts_UK:\n dico_F_0 = dico_zero_pts_UK\n elif system == 'ESO' and band in dico_zero_pts_UK:\n dico_F_0 = dico_zero_pts_ESO \n else:\n msg = 'Combination of band name and band system not recognized.'\n raise TypeError(msg)\n F_0 = dico_F_0[band][1]\n if system == 'ESO':\n # convert from W m-2 mu-1 to Jy\n F_0 = convert_F_units(F_0, dico_F_0[band][0], in_unit='si', \n out_unit='jy')\n \n if conversion == 'to_mag':\n return -2.5*np.log10(value/F_0)\n elif conversion == 'to_flux':\n return F_0*np.power(10.,-value/2.5)\n else:\n msg = \"conversion not recognized, must be 'to_mag' or 'to_flux'.\"\n raise TypeError(msg)","def match_units(self, other):\n for key in self.photons.colnames:\n if key in other.photons.colnames:\n if other[key].unit:\n unit = other[key].unit\n if str(unit).lower() == 'none' and str(self[key].unit).lower() == 'none':\n continue\n self[key].convert_unit_to(unit)","def euroadolaramerica(x):\r\n\tconversion = x * 1.35750\r\n\treturn conversion","def test_measurment(self):\r\n self.assertEqual(Converter.MeasurmentWorldtoUS(10, \"km\"), 6.214)\r\n self.assertEqual(Converter.MeasurmentWorldtoUS(10, \"m\"), 10.936)\r\n self.assertEqual(Converter.MeasurmentWorldtoUS(10, \"cm\"), 0.328)\r\n self.assertEqual(Converter.MeasurmentWorldtoUS(10, \"mm\"), 0.394)\r\n self.assertEqual(Converter.MeasurmentUStoWorld(10, \"mi\"), 16.093)\r\n self.assertEqual(Converter.MeasurmentUStoWorld(10, \"yd\"), 9.144)\r\n self.assertEqual(Converter.MeasurmentUStoWorld(10, \"ft\"), 304.8)\r\n self.assertEqual(Converter.MeasurmentUStoWorld(10, \"in\"), 254)","def spice_unit_convert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result /= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result *= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\n result *= numeric(spice_unit_unconvert([part, \"1.0\"], restrict))\n return str(result)\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n else:\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n newvalue = numeric(valuet[1]) * 0.01\n return str(newvalue)\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def extract_specs(self):\n vDeflection_unit = \"lcd-info.{}.conversion-set.conversion.force.scaling.unit.unit\".format(\n self.channel_numbers[\"vDeflection\"])\n self.units[\"vDeflection\"] = self.general[vDeflection_unit]\n\n height_unit = \"lcd-info.{}.conversion-set.conversion.nominal.scaling.unit.unit\".format(\n self.channel_numbers[\"height\"])\n self.units[\"height\"] = self.general[height_unit]","def test_convert():","def units_to_pixels(self,units_):\n if type(units_) == str and units_.lower() in [\"fwhm\",\"psf\"]:\n units_ = self.fwhm\n\n return super(Image, self).units_to_pixels(units_, target=self.target)","def convert_pressure(self, event):\n try:\n #Compare other unit to one unit(pascals)\n current_value, current_unit = float(\"0\" + str(self.v.get())), self.dropdown.get()\n unit_comp = {\"atm\": 101325.0, \"bars\": 100000.0, \"centimeters mercury\": 1333.22, \"centimeters water\": 98.0665, \"feet of water\": 2989.06692, \"hectopascals\": 100.0, \"inches of mercury\": 3386.388, \"inches of water\": 249.08891, \"kilogram-force/sq.centimeter\": 98066.5, \"kilogram-force/sq.meter\": 9.80665, \"kilonewtons/sq.meter\": 1000.0, \"kilonewtons/sq.millimeter\": 1000000000.0, \"kilopascals\": 1000.0, \"kips/sq.inch\": 6894760.0, \"meganewtons/sq.meter\": 1000000.0, \"meganewtons/sq.millimeter\": 1000000000000.0, \"meters of water\": 9806.65, \"millibars\": 100.0, \"millimeters of mercury\": 133.322, \"millimeters of water\": 9.80665, \"newtons/sq.centimeter\": 10000.0, \"newtons/sq.meter\": 1.0, \"newtons/sq.millimeter\": 1000000.0, \"pascals\": 1.0, \"poundals/sq.foot\": 1.44816, \"pounds-force/sq.foot\": 47.88, \"pounds-force/sq.inch\": 6894.757, \"tonnes-force/sq.cm\": 98066500.0, \"tonnes-force/sq.meter\": 9806.65, \"tons(UK)-force/sq.foot\": 107251.0, \"tons(UK)-force/sq.inch\": 15444280.0, \"tons(US)-force/sq.foot\": 95760.0, \"tons(US)-force/sq.inch\": 13789500.0, \"torr\": 133.322}\n value_comp, printer = current_value * unit_comp[current_unit], \"\"\n unit_list = sorted(unit_comp.keys())\n unit_list.remove(current_unit)\n for unit in unit_list:\n printer += \"To %s \" % unit + \" \" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\"\", \"\\n\"][unit_list[-1] != unit]\n except ValueError: #In case user enter the other type of value, not Int or Float\n printer = \"Value is invalid.\"\n self.print_text(printer)","def test_human_sym_to_ens(self):\n\n mapper = EnsemblMapper(\n from_type='symbol', to_type='ensembl', host=HOST)\n mapped = mapper.map_ids(['TP53', 'BRCA1'])\n\n assert mapped == ['ENSG00000141510', 'ENSG00000012048']","def test_xyz_to_turbomol_format(self):\n xyz_t1 = converter.xyz_to_turbomol_format(xyz_dict=self.xyz1['dict'])\n xyz_t2 = converter.xyz_to_turbomol_format(xyz_dict=self.xyz2['dict'])\n xyz_t6 = converter.xyz_to_turbomol_format(xyz_dict=self.xyz6['dict'])\n xyz_t6_eht = converter.xyz_to_turbomol_format(xyz_dict=self.xyz6['dict'], charge=0, unpaired=1)\n self.assertEqual(xyz_t1, self.xyz1['Turbomole'])\n self.assertEqual(xyz_t2, self.xyz2['Turbomole'])\n self.assertEqual(xyz_t6, self.xyz6['Turbomole'])\n self.assertEqual(xyz_t6_eht, self.xyz6['Turbomole eht'])","def unitsDetector(self, num):\n try:\n num = int(num)\n except:\n sys.exit('Invalid input! Method only takes ints or floats.')\n \n digits = 0\n while num > 1:\n num /= 10\n digits += 1\n \n digits -= 1\n ind = digits // 3\n units = {3: 'B', 2: 'M', 1: 'K', 0: ''}[ind]\n \n return 10 ** (ind * 3), units","def apply_CGSUnits_conversion(f, dataset, dat, verbose=True):\n\n with h5py.File(f, 'r') as hf:\n cgs = hf[dataset].attrs['CGSConversionFactor']\n\n if cgs != 1.0:\n if verbose:\n print(\"Converting to CGS units. (Multiplication by CGS conversion factor = %f)\" % cgs)\n return dat * cgs\n else:\n if verbose:\n print(\"Converting to CGS units. No conversion needed!\")\n return dat","def test_convert_from_inhg():\n inhg = 30\n assert pressure_util.convert(inhg, PRESSURE_INHG, PRESSURE_PSI) == pytest.approx(\n 14.7346266155\n )\n assert pressure_util.convert(inhg, PRESSURE_INHG, PRESSURE_HPA) == pytest.approx(\n 1015.9167\n )\n assert pressure_util.convert(inhg, PRESSURE_INHG, PRESSURE_PA) == pytest.approx(\n 101591.67\n )\n assert pressure_util.convert(inhg, PRESSURE_INHG, PRESSURE_MBAR) == pytest.approx(\n 1015.9167\n )","def get_species_list() -> list:\n c2h2_xyz = {'symbols': ('C', 'C', 'H', 'H'), 'isotopes': (12, 12, 1, 1),\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.203142), (0.0, -0.0, 2.265747), (-0.0, -0.0, -1.062605))}\n ch4_xyz = {'symbols': ('C', 'H', 'H', 'H', 'H'), 'isotopes': (12, 1, 1, 1, 1),\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.08744517), (1.02525314, 0.0, -0.36248173),\n (-0.51262658, 0.88789525, -0.36248173), (-0.51262658, -0.88789525, -0.36248173))}\n co2_xyz = {'symbols': ('C', 'O', 'O'), 'isotopes': (12, 16, 16),\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.1594846), (0.0, 0.0, -1.1594846))}\n co_xyz = {'symbols': ('O', 'C'), 'isotopes': (16, 12), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.12960815))}\n f2_xyz = {'symbols': ('F', 'F'), 'isotopes': (19, 19), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.3952041))}\n ch2o_xyz = {'symbols': ('O', 'C', 'H', 'H'), 'isotopes': (16, 12, 1, 1),\n 'coords': ((0.0, 0.0, 0.674622), (0.0, 0.0, -0.529707),\n (0.0, 0.935488, -1.109367), (0.0, -0.935488, -1.109367))}\n h2o_xyz = {'symbols': ('O', 'H', 'H'), 'isotopes': (16, 1, 1),\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.95691441), (0.92636305, 0.0, -0.23986808))}\n h2_xyz = {'symbols': ('H', 'H'), 'isotopes': (1, 1), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.74187646))}\n hcn_xyz = {'symbols': ('C', 'N', 'H'), 'isotopes': (12, 14, 1),\n 'coords': ((0.0, 0.0, -0.500365), (0.0, 0.0, 0.65264), (0.0, 0.0, -1.566291))}\n hf_xyz = {'symbols': ('F', 'H'), 'isotopes': (19, 1), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.91538107))}\n n2o_xyz = {'symbols': ('N', 'N', 'O'), 'isotopes': (14, 14, 16),\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.12056262), (0.0, 0.0, 2.30761092))}\n n2_xyz = {'symbols': ('N', 'N'), 'isotopes': (14, 14), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.09710935))}\n nh3_xyz = {'symbols': ('N', 'H', 'H', 'H'), 'isotopes': (14, 1, 1, 1),\n 'coords': ((0.0, 0.0, 0.11289), (0.0, 0.938024, -0.263409),\n (0.812353, -0.469012, -0.263409), (-0.812353, -0.469012, -0.263409))}\n oh_xyz = {'symbols': ('O', 'H'), 'isotopes': (16, 1), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.967))}\n cl2_xyz = {'symbols': ('Cl', 'Cl'), 'isotopes': (35, 35), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.1))}\n\n c2h2 = ARCSpecies(label='C2H2', smiles='C#C', multiplicity=1, charge=0)\n c2h2.initial_xyz = c2h2_xyz\n\n ch4 = ARCSpecies(label='CH4', smiles='C', multiplicity=1, charge=0)\n ch4.initial_xyz = ch4_xyz\n\n co2 = ARCSpecies(label='CO2', smiles='O=C=O', multiplicity=1, charge=0)\n co2.initial_xyz = co2_xyz\n\n co = ARCSpecies(label='CO', smiles='[C-]#[O+]', multiplicity=1, charge=0)\n co.initial_xyz = co_xyz\n\n f2 = ARCSpecies(label='F2', smiles='[F][F]', multiplicity=1, charge=0)\n f2.initial_xyz = f2_xyz\n\n ch2o = ARCSpecies(label='CH2O', smiles='C=O', multiplicity=1, charge=0)\n ch2o.initial_xyz = ch2o_xyz\n\n h2o = ARCSpecies(label='H2O', smiles='O', multiplicity=1, charge=0)\n h2o.initial_xyz = h2o_xyz\n\n h2 = ARCSpecies(label='H2', smiles='[H][H]', multiplicity=1, charge=0)\n h2.initial_xyz = h2_xyz\n\n hcn = ARCSpecies(label='HCN', smiles='C#N', multiplicity=1, charge=0)\n hcn.initial_xyz = hcn_xyz\n\n hf = ARCSpecies(label='HF', smiles='F', multiplicity=1, charge=0)\n hf.initial_xyz = hf_xyz\n\n n2o = ARCSpecies(label='N2O', smiles='[N-]=[N+]=O', multiplicity=1, charge=0)\n n2o.initial_xyz = n2o_xyz\n\n n2 = ARCSpecies(label='N2', smiles='N#N', multiplicity=1, charge=0)\n n2.initial_xyz = n2_xyz\n\n nh3 = ARCSpecies(label='NH3', smiles='N', multiplicity=1, charge=0)\n nh3.initial_xyz = nh3_xyz\n\n oh = ARCSpecies(label='OH', smiles='[OH]', multiplicity=2, charge=0)\n oh.initial_xyz = oh_xyz\n\n cl2 = ARCSpecies(label='Cl2', smiles='[Cl][Cl]', multiplicity=1, charge=0)\n cl2.initial_xyz = cl2_xyz\n\n species_list = [c2h2, ch4, co2, co, f2, ch2o, h2o, h2, hcn, hf, n2o, n2, nh3, oh, cl2]\n\n return species_list","def divide_to_species(self):\n titles = []\n for i in self.rest:\n titles.append(i.title.split(\" \"))\n for i in range(len(titles)):\n for j in range(i, len(titles)):\n if titles[i][0] == titles[j][0] and titles[i][1] == titles[j][1]:\n if \" \".join(titles[i]) not in [z.title for z in self.species[\" \".join(titles[i][:2])]]:\n self.rest[i].species = \" \".join(titles[i])\n self.species[\" \".join(titles[i][:2])].append(self.rest[i])\n if \" \".join(titles[j]) not in [z.title for z in self.species[\" \".join(titles[j][:2])]]:\n self.rest[j].species = \" \".join(titles[j])\n self.species[\" \".join(titles[j][:2])].append(self.rest[j])\n\n self.name_of_species = list(self.species.keys())\n\n for i in self.species.keys():\n self.count_species[i] = len(self.species[i])","def ng(nanograms):\n return Unit(nanograms,\"nanogram\")","def test_jy_to_mk_units():\n test_fq = np.array([0.1]) * units.GHz\n jy_to_mk = utils.jy_to_mk(test_fq)\n test_conversion = const.c**2 / (2 * test_fq.to(\"1/s\") ** 2 * const.k_B) * units.sr\n test_conversion = test_conversion.to(\"mK*sr/Jy\")\n assert test_conversion.unit.to_string() == jy_to_mk.unit.to_string()","def testOutputRichness(self):\n self.assertEqual(176, self.coal1.get_species_richness())\n self.assertEqual(215, self.coal2.get_species_richness())\n self.assertEqual(211, self.coal3.get_species_richness())\n self.assertNotEqual(self.coal1.get_species_richness(), self.coal2.get_species_richness())\n self.assertNotEqual(self.coal1.get_species_richness(), self.coal3.get_species_richness())\n self.assertNotEqual(1214, self.coal4.get_species_richness())","def species_converter():\n \n geneD = gene_list_converter() # dict with keys as human gene IDS, and values as human gene symbols\n convertD = homologue_parser() # dict with human gene symbols as keys, and mouse gene symbols as values\n# k = 0\n# for i,j in geneD.items():\n# print(i,j)\n# k += 1\n# if k == 10000: break\n# print(\"------------------------------------------------\")\n# k = 0\n# for i,j in convertD.items():\n# print(i,j)\n# k += 1\n# if k == 100: break\n \n procD = {} # key is human gene ID, value is a dict with human gene symbol as key, mouse gne symbol as value\n missL = []\n missIDL = []\n \n for geneK, geneV in geneD.items(): # geneK: human gene ID, geneV = human gene symbol\n if geneV == \"-\": # handle missing gene symbols\n procD[geneK] = {\"-\": [\"-\"]}\n continue\n \n if geneV in convertD:\n if geneK in procD:\n print(geneK,geneV,procD[geneK])\n raise ValueError\n \n else: procD[geneK] = {geneV: convertD[geneV]}\n \n else: \n missL.append(geneV) # collect gene symbols for which no mouse homologue was found\n missIDL.append(geneK) # collect matching gene IDs too\n procD[geneK] = {geneV: [\"-\"]} # store entries as missing for now\n \n missSeqD = prot_sequence_finder(missL) # prepare a dict with keys as missing human gene symbols and values as their sequences in humans where applicable\n missNameL = []\n missGIL = []\n print(\"BLASTing \" + str(len(missSeqD)) + \" sequences...\")\n for keyS, valueS in missSeqD.items():\n missGIL.append(blaster(valueS)) # blast sequences and get their mouse refseq protein GI. this step will take a lot of time. this list will contain mouse protein genbank accessions\n missNameL.append(keyS) # the matching human gene symbols\n \n missSymbolD = prot_id_converter(missGIL, \"10090\", \"genbankproteinaccession\", \"genesymbol\") # convert protein GIs to gene symbols. keys are mouse protein GIs, values are mouse gene symbols\n print(missSymbolD)\n\n \n for i in range(len(missIDL)):\n if missL[i] in missNameL: procD[missIDL[i]] = {missL[i]: [missSymbolD[missGIL[missNameL.index(missL[i])]]]} \n \n mouseGeneL = []\n for keyS in procD.keys():\n for valueL in procD[keyS].values(): \n if valueL == [\"-\"]: continue\n for valueI in valueL:\n if valueI in mouseGeneL: continue\n mouseGeneL.append(valueI)\n \n mouseD = prot_id_converter(mouseGeneL, \"10090\", \"genesymbol\", \"geneid\")\n \n with file_importer(\"data/converted_gene_list.csv\", \"w\") as outF:\n for keyS in procD.keys():\n outF.write(keyS + \",\")\n for keyN, valueN in procD[keyS].items():\n outF.write(keyN + \",\")\n if keyN == \"-\":\n outF.write(\"-,-\\n\")\n continue\n valL = []\n for valueI in valueN:\n if valueI in mouseD: valL.append(mouseD[valueI])\n else: valL.append(\"-\")\n \n if valueI is valueN[-1]: outF.write(valueI + \",\")\n else: outF.write(valueI + \";\")\n \n for valI in valL:\n if valI is valL[-1]: \n if \"//\" in valI: \n valIL = valI.split(\"//\")\n for valILI in valIL:\n if valILI is valIL[-1]: outF.write(valILI + \"\\n\")\n else: outF.write(valILI + \";\")\n else: outF.write(valI + \"\\n\")\n \n else: \n if \"//\" in valI: \n valIL = valI.split(\"//\")\n for valILI in valIL:\n outF.write(valILI + \";\")\n else: outF.write(valI + \";\")\n print(\"file written\")","def test_different_units(self):\n self.temperature.convert_units(\"celsius\")\n self.relative_humidity.convert_units(\"1\")\n self.pressure.convert_units(\"kPa\")\n result = WetBulbTemperature().create_wet_bulb_temperature_cube(\n self.temperature, self.relative_humidity, self.pressure\n )\n self.assertArrayAlmostEqual(result.data, self.expected_wbt_data, decimal=3)\n self.assertEqual(result.units, Unit(\"K\"))","def convert_H_kJmol(en_H):\n return en_H/kJmol_H","def test_convert_from_hpascals():\n hpascals = 1000\n assert pressure_util.convert(hpascals, PRESSURE_HPA, PRESSURE_PSI) == pytest.approx(\n 14.5037743897\n )\n assert pressure_util.convert(\n hpascals, PRESSURE_HPA, PRESSURE_INHG\n ) == pytest.approx(29.5299801647)\n assert pressure_util.convert(hpascals, PRESSURE_HPA, PRESSURE_PA) == pytest.approx(\n 100000\n )\n assert pressure_util.convert(\n hpascals, PRESSURE_HPA, PRESSURE_MBAR\n ) == pytest.approx(1000)","def test_genbank_to_genome_taxonomy(self):\n result = self.gfu.genbank_to_genome(self.ctx, {\n 'workspace_name': self.ws_name,\n 'generate_ids_if_needed': 'true', # why is this a string\n 'taxon_id': '3702',\n 'file': {\n 'path': f\"{_DATA_PATH}/wigglesworthia/genome.gb\"\n },\n 'genome_name': str(uuid4()),\n })\n ('result', result)\n ref = result[0]['genome_ref']\n self.assertTrue(ref, 'Genome ref exists')\n info = result[0]['genome_info']\n typ = info[2]\n self.assertTrue(typ.startswith('KBaseGenomes.Genome'))\n info_details = info[-1]\n self.assertEqual(info_details['Taxonomy'], (\n \"cellular organisms;Eukaryota;Viridiplantae;\"\n \"Streptophyta;Streptophytina;Embryophyta;Tracheophyta;\"\n \"Euphyllophyta;Spermatophyta;Magnoliopsida;Mesangiospermae;\"\n \"eudicotyledons;Gunneridae;Pentapetalae;rosids;malvids;\"\n \"Brassicales;Brassicaceae;Camelineae;Arabidopsis\"\n ))\n self.assertEqual(info_details['Size'], '697724')\n self.assertEqual(info_details['Source'], 'Genbank')\n self.assertEqual(info_details['Name'], 'Wigglesworthia glossinidia endosymbiont of Glossina brevipalpis')\n self.assertEqual(info_details['GC content'], '0.22479')\n self.assertEqual(info_details['Genetic code'], '11')\n self.assertEqual(info_details['Number of Genome Level Warnings'], '1')\n self.assertEqual(info_details['Source ID'], 'BA000021')\n self.assertEqual(info_details['Number of Protein Encoding Genes'], '20')\n self.assertEqual(info_details['Domain'], 'Eukaryota')\n self.assertTrue(info_details['Assembly Object'])\n self.assertEqual(info_details['Number contigs'], '1')\n self.assertEqual(info_details['Number of CDS'], '20')\n self.assertTrue(info_details['MD5'])","def convert_units(array, in_units=\"None\"):\n if in_units == \"None\" or in_units is None:\n return array\n else:\n raise Exception(\"Unsupported unit for bispectrum descriptors.\")","def get_quantity( self, species, quantity ) :\n\n #NB (for developers): this is a very simple implementation\n #one must take care of the order of search of particle quantities\n #'ux','uy','uz' etc. so that the routine effectively works by just\n #using the replace method on strings. In addition, double character\n #quantities containing other quantitities (e.g 'ex' contains 'x')\n #are replaced with numbered quantities 'e1' to avoid collisions\n #with replace().\n\n dict_keys_val=dict()\n if \"ux\" in quantity :\n dict_keys_val[\"u1\"]=species.getux(gather=False)\n quantity=quantity.replace(\"ux\",\"u1\")\n if \"uy\" in quantity :\n dict_keys_val[\"u2\"]=species.getuy(gather=False)\n quantity=quantity.replace(\"uy\",\"u2\")\n if \"uz\" in quantity :\n dict_keys_val[\"u3\"]=species.getuz(gather=False)\n quantity=quantity.replace(\"uz\",\"u3\")\n if \"ex\" in quantity :\n dict_keys_val[\"e1\"]=species.getex(gather=False)\n quantity=quantity.replace(\"ex\",\"e1\")\n if \"ey\" in quantity :\n dict_keys_val[\"e2\"]=species.getey(gather=False)\n quantity=quantity.replace(\"ey\",\"e2\")\n if \"ez\" in quantity :\n dict_keys_val[\"e3\"]=species.getez(gather=False)\n quantity=quantity.replace(\"ez\",\"e3\")\n if \"bx\" in quantity :\n dict_keys_val[\"b1\"]=species.getbx(gather=False)\n quantity=quantity.replace(\"bx\",\"b1\")\n if \"by\" in quantity :\n dict_keys_val[\"b2\"]=species.getby(gather=False)\n quantity=quantity.replace(\"by\",\"b2\")\n if \"bz\" in quantity :\n dict_keys_val[\"b3\"]=species.getbz(gather=False)\n quantity=quantity.replace(\"bz\",\"b3\")\n if \"w\" in quantity :\n dict_keys_val[\"w\"]=species.getweights(gather=False)\n if \"x\" in quantity :\n dict_keys_val[\"x\"]=species.getx(gather=False)\n if \"y\" in quantity :\n dict_keys_val[\"y\"]=species.gety(gather=False)\n if \"z\" in quantity :\n dict_keys_val[\"z\"]=species.getz(gather=False)\n if \"id\" in quantity:\n # The ssnid is stored in Warp as a float. Thus, it needs\n # to be converted to the nearest integer (rint)\n dict_keys_val[\"id\"] = \\\n (np.rint( species.getssn(gather=False) )).astype('uint64')\n\n string_to_exec=quantity\n for keys in dict_keys_val.keys():\n string_to_exec=string_to_exec.replace(keys,\"dict_keys_val[\\'\"+keys+\"\\']\")\n string_to_exec='quantity_array = '+string_to_exec\n local_dict = {'dict_keys_val':dict_keys_val, 'quantity_array':None}\n exec(string_to_exec, globals(), local_dict)\n\n return( local_dict['quantity_array'] )","def units(self, x):\n u = ''.join([chr(d) for d in self[x]['units'][:]])\n if (u in ['n/a']) and (x in ['latitude', 'longitude']):\n u = 'radian' # assume radians\n return u","def test_number(self):\n descriptor = clone(SPECIES_OBSERVATION_SCHEMA)\n record = {\n 'Observation Date': \"18/08/2016\",\n 'Latitude': -32,\n 'Longitude': 115,\n 'Species Name': 1234\n }\n schema = SpeciesObservationSchema(descriptor)\n with self.assertRaises(Exception):\n schema.cast_species_name(record)","def test_saturation_mixing_ratio_dimensions():\n p = 998. * units.mbar\n temp = 20 * units.celsius\n assert str(saturation_mixing_ratio(p, temp).units) == 'dimensionless'","def test_change_units(self):\n s = State(\"water\", T=Q_(100, \"degC\"), p=Q_(1.0, \"atm\"), units=\"EE\")\n assert s.units == \"EE\"\n s.units = \"SI\"\n assert s.units == \"SI\"\n assert s.cv.units == \"kilojoule / kelvin / kilogram\"\n assert s.cp.units == \"kilojoule / kelvin / kilogram\"\n assert s.s.units == \"kilojoule / kelvin / kilogram\"\n assert s.h.units == \"kilojoule / kilogram\"\n assert s.T.units == \"degree_Celsius\"\n assert s.u.units == \"kilojoule / kilogram\"\n assert s.v.units == \"meter ** 3 / kilogram\"\n assert s.p.units == \"bar\"","def cast_tech(self):\n # type: () -> string_types\n return self._cast_tech","def to(self, unit, equivalencies=[], freq=None):\n\n if not isinstance(unit, u.Unit):\n unit = u.Unit(unit)\n\n if unit == self.unit:\n # No copying\n return self\n\n if ((self.unit.is_equivalent(u.Jy / u.beam) and\n not any({u.Jy/u.beam, u.K}.issubset(set(eq)) for eq in equivalencies))):\n # the 'not any' above checks that there is not already a defined\n # Jy<->K equivalency. If there is, the code below is redundant\n # and will cause problems.\n\n if hasattr(self, 'beams'):\n factor = (self.jtok_factors(equivalencies=equivalencies) *\n (self.unit*u.beam).to(u.Jy))\n else:\n # replace \"beam\" with the actual beam\n if not hasattr(self, 'beam'):\n raise ValueError(\"To convert objects with Jy/beam units, \"\n \"the object needs to have a beam defined.\")\n brightness_unit = self.unit * u.beam\n\n # create a beam equivalency for brightness temperature\n if freq is None:\n try:\n freq = self.with_spectral_unit(u.Hz).spectral_axis\n except AttributeError:\n raise TypeError(\"Object of type {0} has no spectral \"\n \"information. `freq` must be provided for\"\n \" unit conversion from Jy/beam\"\n .format(type(self)))\n else:\n if not freq.unit.is_equivalent(u.Hz):\n raise u.UnitsError(\"freq must be given in equivalent \"\n \"frequency units.\")\n\n bmequiv = self.beam.jtok_equiv(freq)\n # backport to handle astropy < 3: the beam equivalency was only\n # modified to handle jy/beam in astropy 3\n if bmequiv[0] == u.Jy:\n bmequiv.append([u.Jy/u.beam, u.K, bmequiv[2], bmequiv[3]])\n\n factor = brightness_unit.to(unit,\n equivalencies=bmequiv + list(equivalencies))\n\n else:\n # scaling factor\n factor = self.unit.to(unit, equivalencies=equivalencies)\n\n converted_array = (self.quantity * factor).value\n\n # use private versions of variables, not the generated property\n # versions\n # Not entirely sure the use of __class__ here is kosher, but we do want\n # self.__class__, not super()\n new = self.__class__(value=converted_array, unit=unit, copy=True,\n wcs=self._wcs, meta=self._meta, mask=self._mask,\n header=self._header)\n\n return new","def testRichness(self):\n self.assertEqual(1184, self.tree.get_species_richness(1))\n self.assertEqual(1677, self.tree.get_species_richness(2))","def units_to_fits(unit):\n if unit is None:\n unit = Unit('')\n return unit.to_string(\"fits\").upper()","def _format_numbers(smth: any) -> any:\n if isinstance(smth, int):\n return float(smth)\n elif smth == 'N.V.':\n return 0.0 # meaning, wine is of type 'non-vintage' and is made of grapes from more than one harvest\n else:\n return smth","def testRichness(self):\n self.assertEqual(279, self.tree.get_species_richness(1))\n self.assertEqual(281, self.tree.get_species_richness(2))","def convert(self):\n return _libsbml.SBMLUnitsConverter_convert(self)","def get_units(self,):\n self.UNITS = {'pressure':'Pa',}\n return","def FeatureValueFormat(singlegene):\n comp_exon = np.zeros((len(singlegene['exons']),), dtype=np.object)\n for i in range(len(singlegene['exons'])):\n comp_exon[i]= np.array(singlegene['exons'][i])\n singlegene['exons'] = comp_exon\n comp_cds = np.zeros((len(singlegene['cds_exons']),), dtype=np.object)\n for i in range(len(singlegene['cds_exons'])):\n comp_cds[i]= np.array(singlegene['cds_exons'][i])\n singlegene['cds_exons'] = comp_cds\n comp_utr3 = np.zeros((len(singlegene['utr3_exons']),), dtype=np.object)\n for i in range(len(singlegene['utr3_exons'])):\n comp_utr3[i]= np.array(singlegene['utr3_exons'][i])\n singlegene['utr3_exons'] = comp_utr3\n comp_utr5 = np.zeros((len(singlegene['utr5_exons']),), dtype=np.object)\n for i in range(len(singlegene['utr5_exons'])):\n comp_utr5[i]= np.array(singlegene['utr5_exons'][i])\n singlegene['utr5_exons'] = comp_utr5\n comp_transcripts = np.zeros((len(singlegene['transcripts']),), dtype=np.object)\n for i in range(len(singlegene['transcripts'])):\n comp_transcripts[i]= np.array(singlegene['transcripts'][i])\n singlegene['transcripts'] = comp_transcripts\n comp_tss = np.zeros((len(singlegene['tss']),), dtype=np.object)\n for i in range(len(singlegene['tss'])):\n comp_tss[i]= np.array(singlegene['tss'][i])\n singlegene['tss'] = comp_tss\n comp_tis = np.zeros((len(singlegene['tis']),), dtype=np.object)\n for i in range(len(singlegene['tis'])):\n comp_tis[i]= np.array(singlegene['tis'][i])\n singlegene['tis'] = comp_tis\n comp_cleave = np.zeros((len(singlegene['cleave']),), dtype=np.object)\n for i in range(len(singlegene['cleave'])):\n comp_cleave[i]= np.array(singlegene['cleave'][i])\n singlegene['cleave'] = comp_cleave\n comp_cdsStop = np.zeros((len(singlegene['cdsStop']),), dtype=np.object)\n for i in range(len(singlegene['cdsStop'])):\n comp_cdsStop[i]= np.array(singlegene['cdsStop'][i])\n singlegene['cdsStop'] = comp_cdsStop\n\n return singlegene","def serotype_escherichia(metadata, analysistype):\n for sample in metadata:\n # Initialise negative results to be overwritten when necessary\n sample[analysistype].best_o_pid = '-'\n sample[analysistype].o_genes = ['-']\n sample[analysistype].o_set = ['-']\n sample[analysistype].best_h_pid = '-'\n sample[analysistype].h_genes = ['-']\n sample[analysistype].h_set = ['-']\n if sample.general.bestassemblyfile != 'NA':\n if sample.general.closestrefseqgenus in ['Escherichia', 'Shigella']:\n o = dict()\n h = dict()\n for result, percentid in sample[analysistype].blastresults.items():\n if 'O' in result.split('_')[-1]:\n o.update({result: float(percentid)})\n if 'H' in result.split('_')[-1]:\n h.update({result: float(percentid)})\n # O\n try:\n sorted_o = sorted(o.items(), key=operator.itemgetter(1), reverse=True)\n sample[analysistype].best_o_pid = str(sorted_o[0][1])\n\n sample[analysistype].o_genes = [gene for gene, pid in o.items()\n if str(pid) == sample[analysistype].best_o_pid]\n sample[analysistype].o_set = \\\n list(set(gene.split('_')[-1] for gene in sample[analysistype].o_genes))\n except (KeyError, IndexError):\n pass\n # H\n try:\n sorted_h = sorted(h.items(), key=operator.itemgetter(1), reverse=True)\n sample[analysistype].best_h_pid = str(sorted_h[0][1])\n sample[analysistype].h_genes = [gene for gene, pid in h.items()\n if str(pid) == sample[analysistype].best_h_pid]\n sample[analysistype].h_set = \\\n list(set(gene.split('_')[-1] for gene in sample[analysistype].h_genes))\n except (KeyError, IndexError):\n pass\n return metadata","def convert_units(celsius_value, units):\n if units == 0:\n return celsius_value\n if units == 1:\n return celsius_value * 1.8 + 32\n return celsius_value + 273.15","def test_species_to_sdf_file(self):\n path = os.path.join(ARC_PATH, 'arc', 'testing', 'mol.sdf')\n spc = ARCSpecies(label='NCC', smiles='NCC')\n converter.species_to_sdf_file(spc, path)\n with open(path, 'r') as f:\n sdf_content = f.read()\n expected_sdf = \"\"\"\n RDKit 3D\n\n 10 9 0 0 0 0 0 0 0 0999 V2000\n 1.1517 -0.3760 -0.5231 N 0 0 0 0 0 0 0 0 0 0 0 0\n 0.2893 0.4500 0.3115 C 0 0 0 0 0 0 0 0 0 0 0 0\n -1.1415 -0.0561 0.2592 C 0 0 0 0 0 0 0 0 0 0 0 0\n 1.1386 -1.3376 -0.1854 H 0 0 0 0 0 0 0 0 0 0 0 0\n 2.1151 -0.0555 -0.4352 H 0 0 0 0 0 0 0 0 0 0 0 0\n 0.6517 0.4342 1.3447 H 0 0 0 0 0 0 0 0 0 0 0 0\n 0.3279 1.4855 -0.0414 H 0 0 0 0 0 0 0 0 0 0 0 0\n -1.2133 -1.0839 0.6308 H 0 0 0 0 0 0 0 0 0 0 0 0\n -1.7870 0.5726 0.8809 H 0 0 0 0 0 0 0 0 0 0 0 0\n -1.5327 -0.0332 -0.7636 H 0 0 0 0 0 0 0 0 0 0 0 0\n 1 2 1 0\n 1 4 1 0\n 1 5 1 0\n 2 3 1 0\n 2 6 1 0\n 2 7 1 0\n 3 8 1 0\n 3 9 1 0\n 3 10 1 0\nM END\n$$$$\n\"\"\"\n self.assertEqual(sdf_content, expected_sdf)","def test_human_ens_to_sym(self):\n\n mapper = EnsemblMapper(\n from_type='ensembl', to_type='symbol', host=HOST)\n mapped = mapper.map_ids(['ENSG00000141510', 'ENSG00000012048'])\n\n assert mapped == ['TP53', 'BRCA1']","def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)","def isSetUnits(self):\n return _libsbml.Species_isSetUnits(self)","def add_special_conversion(self, from_units, to_units, converter):\n self.special_conversions[(from_units, to_units)] = converter","def test_size_topping(self):\n formatted_name = get_formatted_name('jimi', 'hendrix')\n self.assertEqual(formatted_name, 'Jimi Hendrix')","def fix_coord_units(cat, RA, DEC):\n cat[RA].info.unit = u.deg\n cat[DEC].info.unit = u.deg\n return cat","def test_unit_conversion_incompatible(self):\n self.orography_cube.units = 'K'\n msg = \"Unable to convert from\"\n with self.assertRaisesRegex(ValueError, msg):\n self.plugin_instance.process(self.orography_cube)","def test_conversions(self):\n\n coord_cart_single = np.array([1, 2])\n coord_homo_single = np.array([1, 2, 1])\n coord_cart_multiple = np.array([[1.5, 2.], [2.3, 10.], [11., 18.]])\n coord_homo_multiple = np.array([[1.5, 2., 1.], [2.3, 10., 1.], [11., 18., 1.]])\n\n # Test the single coordinate case\n self.assertTrue(np.allclose(po.cart2homo(coord_cart_single), coord_homo_single))\n self.assertTrue(np.allclose(po.homo2cart(coord_homo_single), coord_cart_single))\n # Test the multiple coordinate case\n self.assertTrue(np.allclose(po.cart2homo(coord_cart_multiple), coord_homo_multiple))\n self.assertTrue(np.allclose(po.homo2cart(coord_homo_multiple), coord_cart_multiple))","def _IsAngstroem(units):\n if isinstance(units, Atom):\n check = units.store.get(\"units\")\n if not check:\n return False\n else:\n check = units\n return check == \"angstroem\" or check == \"angstroemd0\"","def to_isotropic(self) -> None:\n self.uvals = [0.04, 0.0, 0.0, 0.0, 0.0, 0.0]","def test_rmg_mol_from_inchi(self):\n mol1 = converter.rmg_mol_from_inchi('InChI=1S/NO2/c2-1-3')\n mol2 = converter.rmg_mol_from_inchi('InChI=1/CH3NOS/c1-2-3-4-1/h2H,1H2')\n\n self.assertTrue(isinstance(mol1, Molecule))\n self.assertTrue(isinstance(mol2, Molecule))\n\n self.assertEqual(mol1.to_smiles(), '[O]N=O')\n self.assertEqual(mol2.to_smiles(), 'C1NOS1')","def testRichness(self):\n self.assertEqual(2587, self.tree.get_species_richness(1))\n self.assertEqual(3087, self.tree.get_species_richness(2))","def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\n return process_unit_input(value, units, convert=True, registry=registry).v","def test_to_from_iupac(self):\n from openff.toolkit.utils.toolkits import (\n InvalidIUPACNameError,\n UndefinedStereochemistryError,\n )\n\n with pytest.raises(InvalidIUPACNameError):\n Molecule.from_iupac(\".BETA.-PINENE\")\n\n # DrugBank_977, tagged as a problem molecule in earlier tests\n bad_stereo_iupac = (\n \"(~{E},3~{R},5~{S})-7-[4-(4-fluorophenyl)-6-isopropyl-2-\"\n \"[methyl(methylsulfonyl)amino]pyrimidin-5-yl]-3,5-\"\n \"dihydroxy-hept-6-enoic acid\"\n )\n with pytest.raises(UndefinedStereochemistryError):\n Molecule.from_iupac(bad_stereo_iupac)\n\n cholesterol = Molecule.from_smiles(\n \"C[C@H](CCCC(C)C)[C@H]1CC[C@@H]2[C@@]1(CC[C@H]3[C@H]2CC=C4[C@@]3(CC[C@@H](C4)O)C)C\"\n )\n\n cholesterol_iupac = cholesterol.to_iupac()\n\n assert Molecule.are_isomorphic(\n cholesterol, Molecule.from_iupac(cholesterol_iupac)\n )","def testRichness(self):\n self.assertEqual(3460, self.tree.get_species_richness(1))\n self.assertEqual(3613, self.tree.get_species_richness(2))","def test_set_su(self):\n s = State(substance=\"water\")\n s.su = Q_(3028.9867985920914, \"J/(kg*K)\"), Q_(1013250.0, \"J/kg\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(373.1242958476843, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.su[0], Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.su[1], Q_(1013250.0, \"J/kg\")) # type: ignore\n assert np.isclose(s.u, Q_(1013250, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(3028.9867985920914, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(0.4772010021515822, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(1061602.391543017, \"J/kg\")) # type: ignore\n assert np.isclose(s.x, Q_(0.28475636946248034, \"dimensionless\")) # type: ignore","def from_sony(self):\n reason = \"[!] Sonyflake values are 15 hex characters\"\n ts_type = self.ts_types['sony']\n try:\n if len(str(self.sony)) != 15 or not all(char in hexdigits for char in self.sony):\n self.in_sony = indiv_output = combined_output = False\n pass\n else:\n dec_value = int(self.sony, 16)\n ts_value = dec_value >> 24\n unix_ts = (ts_value + 140952960000) * 10\n self.in_sony = dt.utcfromtimestamp(float(unix_ts) /1000.0).strftime('%Y-%m-%d %H:%M:%S.%f')\n indiv_output = str(\"{} {}\".format(ts_type, self.in_sony))\n combined_output = str(\"{}{}\\t\\t\\t{} UTC{}\".format(self.left_color, ts_type, self.in_sony, self.right_color))\n except Exception:\n exc_type, exc_obj, exc_tb = sys.exc_info()\n print(str(exc_type) + \" - \" + str(exc_obj) + \" - line \" + str(exc_tb.tb_lineno))\n self.in_sony = indiv_output = combined_output = False\n return self.in_sony, indiv_output, combined_output, reason","def unit_conversion(thing, units, length=False):\n if 'n/a' == thing:\n return 'n/a'\n try:\n thing = round(thing * CONVERSION[units][0 + length], 2)\n except:\n thing = 'fubar'\n return thing, CONVERSION[units][2 + length]","def _celsius_to_fahrenheit(self) -> None:\n if self.units == \"celsius\":\n self.value = (((self.value / 5) * 9) + 32).__round__(2)\n self.units = \"fahrenheit\"\n else:\n msg = (\n \"Not a valid unit conversion, expected units to be in 'celsius' but instead \"\n + f\"units were in {self.units}.\"\n )\n raise ValueError(msg)","def createPossibleSpeciesFeatureValue(self):\n return _libsbml.SpeciesFeatureType_createPossibleSpeciesFeatureValue(self)","def testFtoCValues(self):\r\n for c,f in self.knownConversionsCtoF:\r\n result = conversions.convertFahrenheittoCelsius(f)\r\n self.assertEqual(c,result)","def setUp(self):\n self.nC4H10O = Species(\n label='n-C4H10O',\n conformer=Conformer(\n E0=(-317.807, 'kJ/mol'),\n modes=[\n IdealGasTranslation(mass=(74.07, \"g/mol\")),\n NonlinearRotor(inertia=([41.5091, 215.751, 233.258], \"amu*angstrom^2\"), symmetry=1),\n HarmonicOscillator(frequencies=(\n [240.915, 341.933, 500.066, 728.41, 809.987, 833.93, 926.308, 948.571, 1009.3, 1031.46, 1076,\n 1118.4, 1184.66, 1251.36, 1314.36, 1321.42, 1381.17, 1396.5, 1400.54, 1448.08, 1480.18, 1485.34,\n 1492.24, 1494.99, 1586.16, 2949.01, 2963.03, 2986.19, 2988.1, 2995.27, 3026.03, 3049.05, 3053.47,\n 3054.83, 3778.88], \"cm^-1\")),\n HinderedRotor(inertia=(0.854054, \"amu*angstrom^2\"), symmetry=1, fourier=(\n [[0.25183, -1.37378, -2.8379, 0.0305112, 0.0028088],\n [0.458307, 0.542121, -0.599366, -0.00283925, 0.0398529]], \"kJ/mol\")),\n HinderedRotor(inertia=(8.79408, \"amu*angstrom^2\"), symmetry=1, fourier=(\n [[0.26871, -0.59533, -8.15002, -0.294325, -0.145357],\n [1.1884, 0.99479, -0.940416, -0.186538, 0.0309834]], \"kJ/mol\")),\n HinderedRotor(inertia=(7.88153, \"amu*angstrom^2\"), symmetry=1, fourier=(\n [[-4.67373, 2.03735, -6.25993, -0.27325, -0.048748],\n [-0.982845, 1.76637, -1.57619, 0.474364, -0.000681718]], \"kJ/mol\")),\n HinderedRotor(inertia=(2.81525, \"amu*angstrom^2\"), symmetry=3, barrier=(2.96807, \"kcal/mol\")),\n ],\n spin_multiplicity=1,\n optical_isomers=1,\n ),\n molecular_weight=(74.07, \"g/mol\"),\n transport_data=TransportData(sigma=(5.94, 'angstrom'), epsilon=(559, 'K')),\n energy_transfer_model=SingleExponentialDown(alpha0=(447.5 * 0.011962, \"kJ/mol\"), T0=(300, \"K\"), n=0.85),\n )\n\n self.nC4H10O.from_smiles('CCCCO')\n\n self.nC4H8 = Species(\n label='n-C4H8',\n conformer=Conformer(\n E0=(-17.8832, 'kJ/mol'),\n modes=[\n IdealGasTranslation(mass=(56.06, \"g/mol\")),\n NonlinearRotor(inertia=([22.2748, 122.4, 125.198], \"amu*angstrom^2\"), symmetry=1),\n HarmonicOscillator(frequencies=(\n [308.537, 418.67, 636.246, 788.665, 848.906, 936.762, 979.97, 1009.48, 1024.22, 1082.96, 1186.38,\n 1277.55, 1307.65, 1332.87, 1396.67, 1439.09, 1469.71, 1484.45, 1493.19, 1691.49, 2972.12, 2994.31,\n 3018.48, 3056.87, 3062.76, 3079.38, 3093.54, 3174.52], \"cm^-1\")),\n HinderedRotor(inertia=(5.28338, \"amu*angstrom^2\"), symmetry=1, fourier=(\n [[-0.579364, -0.28241, -4.46469, 0.143368, 0.126756],\n [1.01804, -0.494628, -0.00318651, -0.245289, 0.193728]], \"kJ/mol\")),\n HinderedRotor(inertia=(2.60818, \"amu*angstrom^2\"), symmetry=3, fourier=(\n [[0.0400372, 0.0301986, -6.4787, -0.0248675, -0.0324753],\n [0.0312541, 0.0538, -0.493785, 0.0965968, 0.125292]], \"kJ/mol\")),\n ],\n spin_multiplicity=1,\n optical_isomers=1,\n ),\n )\n\n self.nC4H8.from_smiles('CCC=C')\n\n self.H2O = Species(\n label='H2O',\n conformer=Conformer(\n E0=(-269.598, 'kJ/mol'),\n modes=[\n IdealGasTranslation(mass=(18.01, \"g/mol\")),\n NonlinearRotor(inertia=([0.630578, 1.15529, 1.78586], \"amu*angstrom^2\"), symmetry=2),\n HarmonicOscillator(frequencies=([1622.09, 3771.85, 3867.85], \"cm^-1\")),\n ],\n spin_multiplicity=1,\n optical_isomers=1,\n ),\n )\n\n self.H2O.from_smiles('O')\n\n self.N2 = Species(\n label='N2',\n molecular_weight=(28.04, \"g/mol\"),\n transport_data=TransportData(sigma=(3.41, \"angstrom\"), epsilon=(124, \"K\")),\n energy_transfer_model=None,\n )\n\n self.N2.from_smiles('N#N')\n\n logging.error('to TS')\n\n self.TS = TransitionState(\n label='TS',\n conformer=Conformer(\n E0=(-42.4373, \"kJ/mol\"),\n modes=[\n IdealGasTranslation(mass=(74.07, \"g/mol\")),\n NonlinearRotor(inertia=([40.518, 232.666, 246.092], \"u*angstrom**2\"), symmetry=1, quantum=False),\n HarmonicOscillator(frequencies=(\n [134.289, 302.326, 351.792, 407.986, 443.419, 583.988, 699.001, 766.1, 777.969, 829.671, 949.753,\n 994.731, 1013.59, 1073.98, 1103.79, 1171.89, 1225.91, 1280.67, 1335.08, 1373.9, 1392.32, 1417.43,\n 1469.51, 1481.61, 1490.16, 1503.73, 1573.16, 2972.85, 2984.3, 3003.67, 3045.78, 3051.77, 3082.37,\n 3090.44, 3190.73, 3708.52], \"kayser\")),\n HinderedRotor(inertia=(2.68206, \"amu*angstrom^2\"), symmetry=3, barrier=(3.35244, \"kcal/mol\")),\n HinderedRotor(inertia=(9.77669, \"amu*angstrom^2\"), symmetry=1, fourier=(\n [[0.208938, -1.55291, -4.05398, -0.105798, -0.104752],\n [2.00518, -0.020767, -0.333595, 0.137791, -0.274578]], \"kJ/mol\")),\n ],\n spin_multiplicity=1,\n optical_isomers=1,\n ),\n frequency=(-2038.34, 'cm^-1'),\n )\n\n self.reaction = Reaction(\n label='dehydration',\n reactants=[self.nC4H10O],\n products=[self.nC4H8, self.H2O],\n transition_state=self.TS,\n kinetics=Arrhenius(A=(0.0387, 'm^3/(mol*s)'), n=2.7, Ea=(2.6192e4, 'J/mol'), T0=(1, 'K'))\n )\n\n self.network = Network(\n label='n-butanol',\n isomers=[Configuration(self.nC4H10O)],\n reactants=[],\n products=[Configuration(self.nC4H8, self.H2O)],\n path_reactions=[self.reaction],\n bath_gas={self.N2: 1.0},\n )\n\n self.pdepnetwork = deepcopy(self.network)\n self.pdepnetwork.__class__ = PDepNetwork\n self.pdepnetwork.source = [self.pdepnetwork.isomers[0].species[0]]\n self.pdepnetwork.index = 1\n self.pdepnetwork.explored = []","def test_inches_valid(self):\n result = inch_to_cm(\"72\\\"\")\n self.assertEqual(result, 183)","def _mps_to_mph(self) -> None:\n if self.units == \"m/s\":\n self.units = \"mph\"\n self.value = (self.value * 2.236936).__round__(2)\n else:\n msg = (\n \"Not a valid unit conversion, expected units to be in 'm/s' but instead \"\n + f\"units were in {self.units}.\"\n )\n raise ValueError(msg)","def convert_from_pj_player_species(pjp_species):\n if not is_pj_player_species(pjp_species):\n raise ValueError(\"convert_from_pj_player_species: Invalid PyJSON Player Species\")\n\n return convert_from_pj_los(pjp_species[1])","def testRichness(self):\n self.assertEqual(3359, self.tree.get_species_richness(1))\n self.assertEqual(3468, self.tree.get_species_richness(2))","def test_smiles_types(self, data, toolkit_class):\n\n if toolkit_class.is_available():\n toolkit = toolkit_class()\n mol = create_cis_1_2_dichloroethene()\n isomeric, explicit_hs, mapped = (\n data[\"isomeric\"],\n data[\"explicit_hydrogens\"],\n data[\"mapped\"],\n )\n if data[\"error\"] is not None:\n with pytest.raises(data[\"error\"]):\n mol.to_smiles(\n isomeric=isomeric,\n explicit_hydrogens=explicit_hs,\n mapped=mapped,\n toolkit_registry=toolkit,\n )\n\n else:\n # make the smiles then do some checks on it\n output_smiles = mol.to_smiles(\n isomeric=isomeric,\n explicit_hydrogens=explicit_hs,\n mapped=mapped,\n toolkit_registry=toolkit,\n )\n if isomeric:\n assert \"\\\\\" in output_smiles\n if explicit_hs:\n assert \"H\" in output_smiles\n if mapped:\n for i in range(1, 7):\n assert f\":{i}\" in output_smiles\n # if the molecule is mapped make it using the mapping\n mol2 = Molecule.from_mapped_smiles(\n mapped_smiles=output_smiles,\n toolkit_registry=toolkit,\n allow_undefined_stereo=not isomeric,\n )\n else:\n # make a molecule from a standard smiles\n mol2 = Molecule.from_smiles(\n smiles=output_smiles,\n allow_undefined_stereo=not isomeric,\n toolkit_registry=toolkit,\n )\n\n isomorphic, atom_map = Molecule.are_isomorphic(\n mol,\n mol2,\n return_atom_map=True,\n aromatic_matching=True,\n formal_charge_matching=True,\n bond_order_matching=True,\n atom_stereochemistry_matching=isomeric,\n bond_stereochemistry_matching=isomeric,\n )\n\n assert isomorphic is True\n if mapped:\n assert {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5} == atom_map\n\n else:\n pytest.skip(\n f\"The required toolkit ({toolkit_class.toolkit_name}) is not available.\"\n )","def convert(x, unit1, unit2):\r\n return conversions[unit1][unit2](x)"],"string":"[\n \"def convert_to(self, units: str) -> None:\\n if self.units == units:\\n return\\n\\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\\n msg = f\\\"\\\"\\\"Not a valid unit conversion. Valid destination units:\\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\\\"\\\"\\\"\\n raise ValueError(msg)\\n\\n if self.units == \\\"celsius\\\" and units == \\\"fahrenheit\\\":\\n self._celsius_to_fahrenheit()\\n elif self.units == \\\"m/s\\\" and units == \\\"km/h\\\":\\n self._mps_to_kph()\\n elif self.units == \\\"m/s\\\" and units == \\\"mph\\\":\\n self._mps_to_mph()\\n else:\\n raise ValueError(\\\"Not a valid unit conversion.\\\")\",\n \"def convertToSpectroGram(self):\",\n \"def test_convert(self):\\n height = 1.6 * self.meter\\n foot = .305 * self.meter\\n inch = 1 / 12 * foot\\n\\n self.assertTrue(abs(height / foot - 5.246) < .001)\\n self.assertTrue(abs(height / inch - 62.951) < .001)\\n\\n newton = self.kgram * self.meter / (self.second ** 2)\\n pound = 4.448222 * newton\\n accel = 9.8 * self.meter / (self.second ** 2)\\n\\n weight = 150 * pound\\n mass = weight / accel\\n self.assertTrue(abs(mass / self.kgram - 68.085) < .001)\",\n \"def useUnits():\",\n \"def convert_mass(self, event):\\n try:\\n #Compare other unit to one unit(kilograms)\\n current_value, current_unit = float(\\\"0\\\" + str(self.v.get())), self.dropdown.get()\\n unit_comp = {\\\"Earth masses\\\": 5.97219e+24, \\\"Solar masses\\\": 1.9890000000000002e+30, \\\"carats\\\": 0.0002, \\\"cental\\\": 45.359237, \\\"decagrams\\\": 0.01, \\\"femtograms\\\": 1e-18, \\\"grains\\\": 6.479891000000001e-05, \\\"grams\\\": 0.001, \\\"hectograms\\\": 0.1, \\\"hundredweights\\\": 50.802345, \\\"kilograms\\\": 1.0, \\\"kilotonnes\\\": 1000000.0, \\\"megatonnes\\\": 1000000000.0, \\\"micrograms\\\": 1e-09, \\\"milligrams\\\": 1e-06, \\\"nanograms\\\": 1e-12, \\\"ounces(US & UK)\\\": 0.02835, \\\"ounces(precious metals)\\\": 0.031103, \\\"picograms\\\": 1e-15, \\\"pounds(US & UK)\\\": 0.453592, \\\"pounds(precious metals)\\\": 0.373242, \\\"slugs\\\": 14.593903, \\\"stones\\\": 6.350293, \\\"tonnes(metric)\\\": 1000.0, \\\"tons(UK)\\\": 1016.046909, \\\"tons(US)\\\": 907.18474}\\n value_comp, printer = current_value * unit_comp[current_unit], \\\"\\\"\\n unit_list = sorted(unit_comp.keys())\\n unit_list.remove(current_unit)\\n for unit in unit_list:\\n printer += \\\"To %s \\\" % unit + \\\" \\\" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\\\"\\\", \\\"\\\\n\\\"][unit_list[-1] != unit]\\n except ValueError: #In case user enter the other type of value, not Int or Float\\n printer = \\\"Value is invalid.\\\"\\n self.print_text(printer)\",\n \"def test_convert_compatible_units(self):\\n result = convert_units(self.arr, 'degC')\\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\\n expected_units = cf_units.Unit('degC')\\n self.assertEquals(result.units, expected_units)\\n self.assertArrayEqual(result.data, expected_data)\",\n \"def latin_to_genus_species(self, latin_name):\\n # Default #\\n genus_name = 'missing'\\n species_name = 'missing'\\n # Lower case the input #\\n latin_name = latin_name.lower()\\n # Split into words #\\n words = latin_name.split()\\n # Get all possible genera #\\n genera = self.known_species['genus'].unique().tolist()\\n # Compare against all possible genera, take first match #\\n for word in words:\\n if genus_name != 'missing': break\\n for genus in genera:\\n if genus_name != 'missing': break\\n if word == genus: genus_name = genus\\n # Get all possible species #\\n all_species = self.known_species.query(\\\"genus==@genus_name\\\")\\n all_species = all_species['species'].unique().tolist()\\n # Compare against all possible species, take first match #\\n for word in words:\\n if species_name != 'missing': break\\n for species in all_species:\\n if species_name != 'missing': break\\n if word == species: species_name = species\\n # Return #\\n return genus_name, species_name\",\n \"def test_convert_same_unit():\\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5\",\n \"def convert_units(data, units):\\n # Build the dictionary of units conversions\\n convert = {'m' : [1.0, 0., 'm'], \\n 'meter' : [1.0, 0., 'm'], \\n 'deg C' : [1.0, 273.15, 'K'], \\n 'Celsius' : [1.0, 273.15, 'K'], \\n 'K' : [1.0, 0., 'K'],\\n 'db' : [1.e4, 101325., 'Pa'], \\n 'Pa' : [1.0, 0., 'Pa'],\\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \\n 'S/m': [1.0, 0., 'S/m'],\\n 'mS/m' : [1.e-3, 0., 'S/m'],\\n 'psu': [1.0, 0., 'psu'], \\n 'salinity': [1.0, 0., 'psu'], \\n 'kg/m^3': [1.0, 0., 'kg/m^3'], \\n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \\n 'm/s': [1.0, 0., 'm/s'], \\n 'mg/l': [1.e-3, 0., 'kg/m^3'],\\n 'meter second-1' : [1.0, 0., 'm/s'],\\n 'm.s-1' : [1.0, 0., 'm/s'],\\n 'pH units' : [1.0, 0., 'pH units'],\\n 'MPa' : [1.e6, 0., 'Pa'],\\n '--' : [1.0, 0., '--'],\\n 'mD' : [9.869233e-16, 0., 'm^2'],\\n 'um' : [1.e-6, 0., 'm'],\\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\\n 'wt.%' : [10., 0., 'psu'],\\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\\n 'm^2' : [1., 0., 'm^2'],\\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \\n } \\n \\n # Make sure the data are a numpy array and the units are a list\\n if isinstance(data, float) or isinstance(data, int):\\n data = np.array([data])\\n if isinstance(data, list):\\n data = np.array(data)\\n if isinstance(units, str) or isinstance(units, unicode):\\n units = [units]\\n if units == None:\\n units = ['']\\n \\n # Make sure you can slice through the columns: must be two-dimensional\\n sh = data.shape\\n data = np.atleast_2d(data)\\n \\n # Allow conversion of a row of data if all of the same unit\\n if len(units) == 1 and data.shape[1] > 1:\\n data = data.transpose()\\n \\n # Create an emtpy array to hold the output\\n out_data = np.zeros(data.shape)\\n out_units = []\\n \\n # Convert the units\\n for i in range(len(units)):\\n try:\\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\\\\n convert[units[i]][1]\\n out_units += [convert[units[i]][2]]\\n except KeyError:\\n print('Do not know how to convert %s to mks units' % units[i])\\n print('Continuing without converting these units...')\\n out_data[:,i] = data[:,i]\\n out_units += units[i]\\n \\n # Return the converted data in the original shape\\n out_data = np.reshape(out_data, sh, 'C')\\n return (out_data, out_units)\",\n \"def test_species(self):\\n spec = input.species('C2H4', os.path.join(self.directory, 'species', 'C2H4', 'ethene.py'))\\n self.assertTrue(isinstance(spec, Species))\\n self.assertEqual(len(spec.molecule), 0)\",\n \"def convert_units(self):\\n for prod in (\\\"ier\\\", \\\"ier_inc_rain\\\"):\\n self.data[prod].data[:] /= 1e6\",\n \"def test_conversion(self):\\n r = self.RNA(\\\"TCAtu\\\")\\n self.assertEqual(str(r), \\\"UCAUU\\\")\\n\\n d = self.DNA(\\\"UCAtu\\\")\\n self.assertEqual(str(d), \\\"TCATT\\\")\",\n \"def describe_a_library_of_units_converters_that():\\n def blows_smoke():\\n assert True\\n\\n def can_convert_psi_to_kpa():\\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\\n\\n # def can_convert_kpa_to_psi():\\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\\n\\n # def can_convert_mpg_to_lp100k():\\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\\n\\n # def can_convert_lp100k_to_mpg():\\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg\",\n \"def convertUnits(self, varname, arr):\\n if varname == \\\"SPDQ\\\" or varname == \\\"PHQ\\\":\\n return arr*2.5e6/1000.\\n return arr\",\n \"def test_hartree_to_si(self):\\n e = converter.hartree_to_si(1)\\n self.assertAlmostEqual(e, 2625.5, places=1)\\n e = converter.hartree_to_si(5)\\n self.assertAlmostEqual(e, 13127.499291814986)\\n e = converter.hartree_to_si(5, kilo=False)\\n self.assertAlmostEqual(e, 13127499.291814985)\\n e = converter.hartree_to_si(-10.752192838993)\\n self.assertAlmostEqual(e, -28229.880775867754)\",\n \"def _check_special_conversion(self, expr):\\n lhs_units = expr.eq.lhs.get_units()\\n rhs_units = expr.eq.rhs.get_units()\\n if lhs_units.dimensionally_equivalent(rhs_units):\\n return\\n for from_units, to_units in self.special_conversions.iterkeys():\\n if (from_units.dimensionally_equivalent(rhs_units)\\n and to_units.dimensionally_equivalent(lhs_units)):\\n # We can apply this conversion\\n self.special_conversions[(from_units, to_units)](expr)\\n DEBUG('units-converter', \\\"Used special conversion from\\\", repr(from_units), \\\"to\\\", repr(to_units))#, \\\"giving\\\", expr.xml())\\n break\",\n \"def testSpeciesRichnessValuesAsExpected(self):\\n self.assertEqual(69, self.tree.get_species_richness(1))\\n self.assertEqual(69, self.tree.get_species_richness(2))\\n self.assertEqual(69, self.tree.get_species_richness(3))\\n self.assertEqual(22, self.tree.get_species_richness(4))\\n self.assertEqual(19, self.tree.get_species_richness(5))\\n self.assertEqual(25, self.tree.get_species_richness(6))\",\n \"def convert_F_units(F, lbda, in_unit='cgs', out_unit='si'):\\n\\n if in_unit == 'cgs':\\n new_F = (F*1e23*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == 'cgsA':\\n new_F = (F*1e27*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == 'si':\\n new_F = (F*1e26*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == \\\"jy\\\":\\n new_F=F\\n else:\\n msg = \\\"in_unit not recognized, try either 'cgs', 'si' or 'jy'.\\\"\\n raise TypeError(msg) \\n if out_unit == 'jy':\\n return new_F\\n elif out_unit == 'cgs':\\n return new_F*1e-23*c.c.value*1e6/np.power(lbda,2)\\n elif out_unit == 'si':\\n return new_F*1e-26*c.c.value*1e6/np.power(lbda,2)\\n else:\\n msg = \\\"out_unit not recognized, try either 'cgs', 'si' or 'jy'.\\\"\\n raise TypeError(msg)\",\n \"def testNSESanityChecks(self):\\n self.assertEqual(100, self.c.get_species_richness())\\n self.assertEqual(67, self.c2.get_species_richness())\",\n \"def test_unit_conversion_compatible(self):\\n self.orography_cube.convert_units('ft')\\n probability_cube = self.plugin_instance.process(self.orography_cube)\\n self.assertIsInstance(probability_cube, iris.cube.Cube)\\n self.assertSequenceEqual(probability_cube.shape,\\n self.reference_cube.shape)\",\n \"def convert_units(data, hdr, conv_to = \\\"surf_br\\\"):\\n \\n data_unit = hdr[\\\"SIGUNIT\\\"]\\n \\n if \\\"Jy/pix\\\" in data_unit:\\n # pixel size in rad\\n px_x = abs(hdr[\\\"CDELT1\\\"])*2*np.pi/360\\n px_y = abs(hdr[\\\"CDELT2\\\"])*2*np.pi/360\\n \\n #pixel size in arcsec\\n \\n px_x = abs(hdr[\\\"CDELT1\\\"])*3600\\n px_y = abs(hdr[\\\"CDELT2\\\"])*3600\\n conversion_factor = 1000/(px_x*px_y)\\n \\n unit_label = \\\"mJy/arcsec^2\\\"\\n \\n #in case we want to convert to units flux, we need to multiply by the size (in steradians) of a pixel.\\n if conv_to == \\\"flux\\\":\\n conversion_factor*=abs(hdr[\\\"CDELT1\\\"])*abs(hdr[\\\"CDELT2\\\"])*(2*np.pi/360)**2\\n unit_label = \\\"mJy\\\"\\n \\n data *= conversion_factor\\n hdr[\\\"SIGUNIT\\\"] = unit_label\\n else:\\n print(\\\"\\\\t[WARNING]\\\\t \\\"+data_unit+\\\" conversion not yet implemented. No conversion performed.\\\")\\n \\n return data, hdr\",\n \"def convert_units(self, units):\\n self.unit_array = self.unit_array.to(units)\",\n \"def convert_same_units(self):\\n # Convert pumping rate data\\n pump_units = \\\"%s3/%s\\\" % (self.len_units, self.time_units)\\n flag = _units.validate_units(pump_units)\\n if flag == 2:\\n self.pumprate.convert_units(self.time_units, pump_units)\\n self.pump_units = pump_units\",\n \"def preprocess_sub_units(self):\\n if self.unit == \\\"char\\\":\\n self.preprocess_char()\\n elif self.unit == \\\"char-ngram\\\":\\n self.preprocess_char_ngram()\\n elif self.unit == \\\"morpheme\\\":\\n self.preprocess_morpheme()\\n elif self.unit == \\\"oracle\\\":\\n self.preprocess_oracle()\\n else:\\n sys.exit(\\\"Unknown unit\\\")\",\n \"def convert_energy(self, event):\\n try:\\n #Compare other unit to one unit(joules)\\n current_value, current_unit = float(\\\"0\\\" + str(self.v.get())), self.dropdown.get()\\n unit_comp = {\\\"Btu(th)\\\": 1054.35, \\\"Btu(mean)\\\": 1055.87, \\\"calories(IT)\\\": 4.1868, \\\"calories(th)\\\": 4.184, \\\"calories(mean)\\\": 4.19002, \\\"calories(15C)\\\": 4.1858, \\\"calories(20C)\\\": 4.1819, \\\"calories(food)\\\": 4186.0, \\\"centigrade heat units\\\": 1900.4, \\\"electron volts\\\": 1.60219 * 10 ** -19, \\\"ergs\\\": 1.0 * 10 ** -7, \\\"foot-pound force\\\": 1.355818, \\\"foot poundals\\\": 0.04214, \\\"gigajoules\\\": 1.0 * 10 ** 9, \\\"horsepower hours\\\": 2684520.0, \\\"inch-pound force\\\": 0.112985, \\\"joules\\\": 1.0, \\\"kilocalories(IT)\\\": 4186.8, \\\"kilocalories(th)\\\": 4184.0, \\\"kilogram-force meters\\\": 9.80665, \\\"kilojoules\\\": 1000.0, \\\"kilowatt hours\\\": 3600000.0, \\\"megajoules\\\": 1.0 * 10 ** 6, \\\"newton meters\\\": 1.0, \\\"therms\\\": 105505585.257348, \\\"watt seconds\\\": 1.0, \\\"watt hours\\\" : 3600.0}\\n value_comp, printer = current_value * unit_comp[current_unit], \\\"\\\"\\n unit_list = sorted(unit_comp.keys())\\n unit_list.remove(current_unit)\\n for unit in unit_list:\\n printer += \\\"To %s \\\" % unit + \\\" \\\" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\\\"\\\", \\\"\\\\n\\\"][unit_list[-1] != unit]\\n except ValueError: #In case user enter the other type of value, not Int or Float\\n printer = \\\"Value is invalid.\\\"\\n self.print_text(printer)\",\n \"def convert_units(unt, origunits):\\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\\n units = origunits\\n convf = 1\\n else:\\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'met':\\n units = 'feet'\\n convf = 3.2808399\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'met' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'fee':\\n units = 'meters'\\n convf = 0.3048\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'kno':\\n units = 'meters/sec'\\n convf = 0.51444444\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'm/s':\\n units = 'knots'\\n convf = 1.9438445\\n else:\\n units = origunits\\n convf = 1\\n else:\\n error('Unknown units')\\n #\\n return units, convf\",\n \"def getUnits(self):\\n return _libsbml.Species_getUnits(self)\",\n \"def setUnits(self, *args):\\n return _libsbml.Species_setUnits(self, *args)\",\n \"def test_convert_nonnumeric_value():\\n with pytest.raises(TypeError):\\n pressure_util.convert(\\\"a\\\", PRESSURE_HPA, PRESSURE_INHG)\",\n \"def test_set_us(self):\\n s = State(substance=\\\"water\\\")\\n s.us = Q_(1013250.0, \\\"J/kg\\\"), Q_(3028.9867985920914, \\\"J/(kg*K)\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.us[0], Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.us[1], Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\",\n \"def convert_F_vs_mag(value, F_0=None, band='H', system='Johnson', \\n conversion='to_mag'): \\n \\n dico_zero_pts_Jo = {'U': [0.36,1823.],\\n 'B': [0.44,4130.],\\n 'V': [0.55,3781.],\\n 'R': [0.71,2941.],\\n 'I': [0.97,2635.],\\n 'J': [1.25,1603.],\\n 'H': [1.60,1075.],\\n 'K': [2.22,667.],\\n 'L': [3.54,288.],\\n 'M': [4.80,170.],\\n 'N': [10.6,36.],\\n 'O': [21.0,9.4]}\\n dico_zero_pts_2M = {'J': [1.235,1594.],\\n 'H': [1.662,1024.],\\n 'K': [2.159,666.7]}\\n dico_zero_pts_UK = {'V': [0.5556,3540.], # TOKUNAGA (from Cohen 1992)\\n 'I': [0.9,2250.], # UKIRT webpage\\n 'J': [1.215,1630.], # TOKUNAGA (from Cohen 1992)\\n 'H': [1.654,1050.], # TOKUNAGA (from Cohen 1992)\\n 'Ks': [2.157,667.], # TOKUNAGA (from Cohen 1992)\\n 'K': [2.179,655.], # TOKUNAGA (from Cohen 1992) \\n 'L': [3.547,276.], # TOKUNAGA (from Cohen 1992) \\n \\\"L'\\\": [3.761,248.], # TOKUNAGA (from Cohen 1992) \\n 'M': [4.769,160.], # TOKUNAGA (from Cohen 1992) \\n '8.7': [8.756,50.], # TOKUNAGA (from Cohen 1992) \\n 'N': [10.472,35.3], # TOKUNAGA (from Cohen 1992) \\n '11.7': [11.653,28.6], # TOKUNAGA (from Cohen 1992) \\n 'Q': [20.13,9.7]} # TOKUNAGA (from Cohen 1992)\\n dico_zero_pts_ESO = {'J': [1.228,3.44e-9], # van der Bliek 1996\\n 'H': [1.651,1.21e-9], # van der Bliek 1996\\n 'K': [2.216,4.12e-10], # van der Bliek 1996\\n \\\"L'\\\": [3.771,5.58e-11], # van der Bliek 1996\\n \\\"M\\\": [4.772,2.21e-11]} # van der Bliek 1996 \\n \\n if F_0 is None:\\n if system == 'Johnson' and band in dico_zero_pts_Jo:\\n dico_F_0 = dico_zero_pts_Jo\\n elif system == '2MASS' and band in dico_zero_pts_2M:\\n dico_F_0 = dico_zero_pts_2M\\n elif system == 'UKIRT' and band in dico_zero_pts_UK:\\n dico_F_0 = dico_zero_pts_UK\\n elif system == 'ESO' and band in dico_zero_pts_UK:\\n dico_F_0 = dico_zero_pts_ESO \\n else:\\n msg = 'Combination of band name and band system not recognized.'\\n raise TypeError(msg)\\n F_0 = dico_F_0[band][1]\\n if system == 'ESO':\\n # convert from W m-2 mu-1 to Jy\\n F_0 = convert_F_units(F_0, dico_F_0[band][0], in_unit='si', \\n out_unit='jy')\\n \\n if conversion == 'to_mag':\\n return -2.5*np.log10(value/F_0)\\n elif conversion == 'to_flux':\\n return F_0*np.power(10.,-value/2.5)\\n else:\\n msg = \\\"conversion not recognized, must be 'to_mag' or 'to_flux'.\\\"\\n raise TypeError(msg)\",\n \"def match_units(self, other):\\n for key in self.photons.colnames:\\n if key in other.photons.colnames:\\n if other[key].unit:\\n unit = other[key].unit\\n if str(unit).lower() == 'none' and str(self[key].unit).lower() == 'none':\\n continue\\n self[key].convert_unit_to(unit)\",\n \"def euroadolaramerica(x):\\r\\n\\tconversion = x * 1.35750\\r\\n\\treturn conversion\",\n \"def test_measurment(self):\\r\\n self.assertEqual(Converter.MeasurmentWorldtoUS(10, \\\"km\\\"), 6.214)\\r\\n self.assertEqual(Converter.MeasurmentWorldtoUS(10, \\\"m\\\"), 10.936)\\r\\n self.assertEqual(Converter.MeasurmentWorldtoUS(10, \\\"cm\\\"), 0.328)\\r\\n self.assertEqual(Converter.MeasurmentWorldtoUS(10, \\\"mm\\\"), 0.394)\\r\\n self.assertEqual(Converter.MeasurmentUStoWorld(10, \\\"mi\\\"), 16.093)\\r\\n self.assertEqual(Converter.MeasurmentUStoWorld(10, \\\"yd\\\"), 9.144)\\r\\n self.assertEqual(Converter.MeasurmentUStoWorld(10, \\\"ft\\\"), 304.8)\\r\\n self.assertEqual(Converter.MeasurmentUStoWorld(10, \\\"in\\\"), 254)\",\n \"def spice_unit_convert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result /= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result *= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\\n result *= numeric(spice_unit_unconvert([part, \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n else:\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n newvalue = numeric(valuet[1]) * 0.01\\n return str(newvalue)\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def extract_specs(self):\\n vDeflection_unit = \\\"lcd-info.{}.conversion-set.conversion.force.scaling.unit.unit\\\".format(\\n self.channel_numbers[\\\"vDeflection\\\"])\\n self.units[\\\"vDeflection\\\"] = self.general[vDeflection_unit]\\n\\n height_unit = \\\"lcd-info.{}.conversion-set.conversion.nominal.scaling.unit.unit\\\".format(\\n self.channel_numbers[\\\"height\\\"])\\n self.units[\\\"height\\\"] = self.general[height_unit]\",\n \"def test_convert():\",\n \"def units_to_pixels(self,units_):\\n if type(units_) == str and units_.lower() in [\\\"fwhm\\\",\\\"psf\\\"]:\\n units_ = self.fwhm\\n\\n return super(Image, self).units_to_pixels(units_, target=self.target)\",\n \"def convert_pressure(self, event):\\n try:\\n #Compare other unit to one unit(pascals)\\n current_value, current_unit = float(\\\"0\\\" + str(self.v.get())), self.dropdown.get()\\n unit_comp = {\\\"atm\\\": 101325.0, \\\"bars\\\": 100000.0, \\\"centimeters mercury\\\": 1333.22, \\\"centimeters water\\\": 98.0665, \\\"feet of water\\\": 2989.06692, \\\"hectopascals\\\": 100.0, \\\"inches of mercury\\\": 3386.388, \\\"inches of water\\\": 249.08891, \\\"kilogram-force/sq.centimeter\\\": 98066.5, \\\"kilogram-force/sq.meter\\\": 9.80665, \\\"kilonewtons/sq.meter\\\": 1000.0, \\\"kilonewtons/sq.millimeter\\\": 1000000000.0, \\\"kilopascals\\\": 1000.0, \\\"kips/sq.inch\\\": 6894760.0, \\\"meganewtons/sq.meter\\\": 1000000.0, \\\"meganewtons/sq.millimeter\\\": 1000000000000.0, \\\"meters of water\\\": 9806.65, \\\"millibars\\\": 100.0, \\\"millimeters of mercury\\\": 133.322, \\\"millimeters of water\\\": 9.80665, \\\"newtons/sq.centimeter\\\": 10000.0, \\\"newtons/sq.meter\\\": 1.0, \\\"newtons/sq.millimeter\\\": 1000000.0, \\\"pascals\\\": 1.0, \\\"poundals/sq.foot\\\": 1.44816, \\\"pounds-force/sq.foot\\\": 47.88, \\\"pounds-force/sq.inch\\\": 6894.757, \\\"tonnes-force/sq.cm\\\": 98066500.0, \\\"tonnes-force/sq.meter\\\": 9806.65, \\\"tons(UK)-force/sq.foot\\\": 107251.0, \\\"tons(UK)-force/sq.inch\\\": 15444280.0, \\\"tons(US)-force/sq.foot\\\": 95760.0, \\\"tons(US)-force/sq.inch\\\": 13789500.0, \\\"torr\\\": 133.322}\\n value_comp, printer = current_value * unit_comp[current_unit], \\\"\\\"\\n unit_list = sorted(unit_comp.keys())\\n unit_list.remove(current_unit)\\n for unit in unit_list:\\n printer += \\\"To %s \\\" % unit + \\\" \\\" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\\\"\\\", \\\"\\\\n\\\"][unit_list[-1] != unit]\\n except ValueError: #In case user enter the other type of value, not Int or Float\\n printer = \\\"Value is invalid.\\\"\\n self.print_text(printer)\",\n \"def test_human_sym_to_ens(self):\\n\\n mapper = EnsemblMapper(\\n from_type='symbol', to_type='ensembl', host=HOST)\\n mapped = mapper.map_ids(['TP53', 'BRCA1'])\\n\\n assert mapped == ['ENSG00000141510', 'ENSG00000012048']\",\n \"def test_xyz_to_turbomol_format(self):\\n xyz_t1 = converter.xyz_to_turbomol_format(xyz_dict=self.xyz1['dict'])\\n xyz_t2 = converter.xyz_to_turbomol_format(xyz_dict=self.xyz2['dict'])\\n xyz_t6 = converter.xyz_to_turbomol_format(xyz_dict=self.xyz6['dict'])\\n xyz_t6_eht = converter.xyz_to_turbomol_format(xyz_dict=self.xyz6['dict'], charge=0, unpaired=1)\\n self.assertEqual(xyz_t1, self.xyz1['Turbomole'])\\n self.assertEqual(xyz_t2, self.xyz2['Turbomole'])\\n self.assertEqual(xyz_t6, self.xyz6['Turbomole'])\\n self.assertEqual(xyz_t6_eht, self.xyz6['Turbomole eht'])\",\n \"def unitsDetector(self, num):\\n try:\\n num = int(num)\\n except:\\n sys.exit('Invalid input! Method only takes ints or floats.')\\n \\n digits = 0\\n while num > 1:\\n num /= 10\\n digits += 1\\n \\n digits -= 1\\n ind = digits // 3\\n units = {3: 'B', 2: 'M', 1: 'K', 0: ''}[ind]\\n \\n return 10 ** (ind * 3), units\",\n \"def apply_CGSUnits_conversion(f, dataset, dat, verbose=True):\\n\\n with h5py.File(f, 'r') as hf:\\n cgs = hf[dataset].attrs['CGSConversionFactor']\\n\\n if cgs != 1.0:\\n if verbose:\\n print(\\\"Converting to CGS units. (Multiplication by CGS conversion factor = %f)\\\" % cgs)\\n return dat * cgs\\n else:\\n if verbose:\\n print(\\\"Converting to CGS units. No conversion needed!\\\")\\n return dat\",\n \"def test_convert_from_inhg():\\n inhg = 30\\n assert pressure_util.convert(inhg, PRESSURE_INHG, PRESSURE_PSI) == pytest.approx(\\n 14.7346266155\\n )\\n assert pressure_util.convert(inhg, PRESSURE_INHG, PRESSURE_HPA) == pytest.approx(\\n 1015.9167\\n )\\n assert pressure_util.convert(inhg, PRESSURE_INHG, PRESSURE_PA) == pytest.approx(\\n 101591.67\\n )\\n assert pressure_util.convert(inhg, PRESSURE_INHG, PRESSURE_MBAR) == pytest.approx(\\n 1015.9167\\n )\",\n \"def get_species_list() -> list:\\n c2h2_xyz = {'symbols': ('C', 'C', 'H', 'H'), 'isotopes': (12, 12, 1, 1),\\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.203142), (0.0, -0.0, 2.265747), (-0.0, -0.0, -1.062605))}\\n ch4_xyz = {'symbols': ('C', 'H', 'H', 'H', 'H'), 'isotopes': (12, 1, 1, 1, 1),\\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.08744517), (1.02525314, 0.0, -0.36248173),\\n (-0.51262658, 0.88789525, -0.36248173), (-0.51262658, -0.88789525, -0.36248173))}\\n co2_xyz = {'symbols': ('C', 'O', 'O'), 'isotopes': (12, 16, 16),\\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.1594846), (0.0, 0.0, -1.1594846))}\\n co_xyz = {'symbols': ('O', 'C'), 'isotopes': (16, 12), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.12960815))}\\n f2_xyz = {'symbols': ('F', 'F'), 'isotopes': (19, 19), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.3952041))}\\n ch2o_xyz = {'symbols': ('O', 'C', 'H', 'H'), 'isotopes': (16, 12, 1, 1),\\n 'coords': ((0.0, 0.0, 0.674622), (0.0, 0.0, -0.529707),\\n (0.0, 0.935488, -1.109367), (0.0, -0.935488, -1.109367))}\\n h2o_xyz = {'symbols': ('O', 'H', 'H'), 'isotopes': (16, 1, 1),\\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.95691441), (0.92636305, 0.0, -0.23986808))}\\n h2_xyz = {'symbols': ('H', 'H'), 'isotopes': (1, 1), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.74187646))}\\n hcn_xyz = {'symbols': ('C', 'N', 'H'), 'isotopes': (12, 14, 1),\\n 'coords': ((0.0, 0.0, -0.500365), (0.0, 0.0, 0.65264), (0.0, 0.0, -1.566291))}\\n hf_xyz = {'symbols': ('F', 'H'), 'isotopes': (19, 1), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.91538107))}\\n n2o_xyz = {'symbols': ('N', 'N', 'O'), 'isotopes': (14, 14, 16),\\n 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.12056262), (0.0, 0.0, 2.30761092))}\\n n2_xyz = {'symbols': ('N', 'N'), 'isotopes': (14, 14), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.09710935))}\\n nh3_xyz = {'symbols': ('N', 'H', 'H', 'H'), 'isotopes': (14, 1, 1, 1),\\n 'coords': ((0.0, 0.0, 0.11289), (0.0, 0.938024, -0.263409),\\n (0.812353, -0.469012, -0.263409), (-0.812353, -0.469012, -0.263409))}\\n oh_xyz = {'symbols': ('O', 'H'), 'isotopes': (16, 1), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 0.967))}\\n cl2_xyz = {'symbols': ('Cl', 'Cl'), 'isotopes': (35, 35), 'coords': ((0.0, 0.0, 0.0), (0.0, 0.0, 1.1))}\\n\\n c2h2 = ARCSpecies(label='C2H2', smiles='C#C', multiplicity=1, charge=0)\\n c2h2.initial_xyz = c2h2_xyz\\n\\n ch4 = ARCSpecies(label='CH4', smiles='C', multiplicity=1, charge=0)\\n ch4.initial_xyz = ch4_xyz\\n\\n co2 = ARCSpecies(label='CO2', smiles='O=C=O', multiplicity=1, charge=0)\\n co2.initial_xyz = co2_xyz\\n\\n co = ARCSpecies(label='CO', smiles='[C-]#[O+]', multiplicity=1, charge=0)\\n co.initial_xyz = co_xyz\\n\\n f2 = ARCSpecies(label='F2', smiles='[F][F]', multiplicity=1, charge=0)\\n f2.initial_xyz = f2_xyz\\n\\n ch2o = ARCSpecies(label='CH2O', smiles='C=O', multiplicity=1, charge=0)\\n ch2o.initial_xyz = ch2o_xyz\\n\\n h2o = ARCSpecies(label='H2O', smiles='O', multiplicity=1, charge=0)\\n h2o.initial_xyz = h2o_xyz\\n\\n h2 = ARCSpecies(label='H2', smiles='[H][H]', multiplicity=1, charge=0)\\n h2.initial_xyz = h2_xyz\\n\\n hcn = ARCSpecies(label='HCN', smiles='C#N', multiplicity=1, charge=0)\\n hcn.initial_xyz = hcn_xyz\\n\\n hf = ARCSpecies(label='HF', smiles='F', multiplicity=1, charge=0)\\n hf.initial_xyz = hf_xyz\\n\\n n2o = ARCSpecies(label='N2O', smiles='[N-]=[N+]=O', multiplicity=1, charge=0)\\n n2o.initial_xyz = n2o_xyz\\n\\n n2 = ARCSpecies(label='N2', smiles='N#N', multiplicity=1, charge=0)\\n n2.initial_xyz = n2_xyz\\n\\n nh3 = ARCSpecies(label='NH3', smiles='N', multiplicity=1, charge=0)\\n nh3.initial_xyz = nh3_xyz\\n\\n oh = ARCSpecies(label='OH', smiles='[OH]', multiplicity=2, charge=0)\\n oh.initial_xyz = oh_xyz\\n\\n cl2 = ARCSpecies(label='Cl2', smiles='[Cl][Cl]', multiplicity=1, charge=0)\\n cl2.initial_xyz = cl2_xyz\\n\\n species_list = [c2h2, ch4, co2, co, f2, ch2o, h2o, h2, hcn, hf, n2o, n2, nh3, oh, cl2]\\n\\n return species_list\",\n \"def divide_to_species(self):\\n titles = []\\n for i in self.rest:\\n titles.append(i.title.split(\\\" \\\"))\\n for i in range(len(titles)):\\n for j in range(i, len(titles)):\\n if titles[i][0] == titles[j][0] and titles[i][1] == titles[j][1]:\\n if \\\" \\\".join(titles[i]) not in [z.title for z in self.species[\\\" \\\".join(titles[i][:2])]]:\\n self.rest[i].species = \\\" \\\".join(titles[i])\\n self.species[\\\" \\\".join(titles[i][:2])].append(self.rest[i])\\n if \\\" \\\".join(titles[j]) not in [z.title for z in self.species[\\\" \\\".join(titles[j][:2])]]:\\n self.rest[j].species = \\\" \\\".join(titles[j])\\n self.species[\\\" \\\".join(titles[j][:2])].append(self.rest[j])\\n\\n self.name_of_species = list(self.species.keys())\\n\\n for i in self.species.keys():\\n self.count_species[i] = len(self.species[i])\",\n \"def ng(nanograms):\\n return Unit(nanograms,\\\"nanogram\\\")\",\n \"def test_jy_to_mk_units():\\n test_fq = np.array([0.1]) * units.GHz\\n jy_to_mk = utils.jy_to_mk(test_fq)\\n test_conversion = const.c**2 / (2 * test_fq.to(\\\"1/s\\\") ** 2 * const.k_B) * units.sr\\n test_conversion = test_conversion.to(\\\"mK*sr/Jy\\\")\\n assert test_conversion.unit.to_string() == jy_to_mk.unit.to_string()\",\n \"def testOutputRichness(self):\\n self.assertEqual(176, self.coal1.get_species_richness())\\n self.assertEqual(215, self.coal2.get_species_richness())\\n self.assertEqual(211, self.coal3.get_species_richness())\\n self.assertNotEqual(self.coal1.get_species_richness(), self.coal2.get_species_richness())\\n self.assertNotEqual(self.coal1.get_species_richness(), self.coal3.get_species_richness())\\n self.assertNotEqual(1214, self.coal4.get_species_richness())\",\n \"def species_converter():\\n \\n geneD = gene_list_converter() # dict with keys as human gene IDS, and values as human gene symbols\\n convertD = homologue_parser() # dict with human gene symbols as keys, and mouse gene symbols as values\\n# k = 0\\n# for i,j in geneD.items():\\n# print(i,j)\\n# k += 1\\n# if k == 10000: break\\n# print(\\\"------------------------------------------------\\\")\\n# k = 0\\n# for i,j in convertD.items():\\n# print(i,j)\\n# k += 1\\n# if k == 100: break\\n \\n procD = {} # key is human gene ID, value is a dict with human gene symbol as key, mouse gne symbol as value\\n missL = []\\n missIDL = []\\n \\n for geneK, geneV in geneD.items(): # geneK: human gene ID, geneV = human gene symbol\\n if geneV == \\\"-\\\": # handle missing gene symbols\\n procD[geneK] = {\\\"-\\\": [\\\"-\\\"]}\\n continue\\n \\n if geneV in convertD:\\n if geneK in procD:\\n print(geneK,geneV,procD[geneK])\\n raise ValueError\\n \\n else: procD[geneK] = {geneV: convertD[geneV]}\\n \\n else: \\n missL.append(geneV) # collect gene symbols for which no mouse homologue was found\\n missIDL.append(geneK) # collect matching gene IDs too\\n procD[geneK] = {geneV: [\\\"-\\\"]} # store entries as missing for now\\n \\n missSeqD = prot_sequence_finder(missL) # prepare a dict with keys as missing human gene symbols and values as their sequences in humans where applicable\\n missNameL = []\\n missGIL = []\\n print(\\\"BLASTing \\\" + str(len(missSeqD)) + \\\" sequences...\\\")\\n for keyS, valueS in missSeqD.items():\\n missGIL.append(blaster(valueS)) # blast sequences and get their mouse refseq protein GI. this step will take a lot of time. this list will contain mouse protein genbank accessions\\n missNameL.append(keyS) # the matching human gene symbols\\n \\n missSymbolD = prot_id_converter(missGIL, \\\"10090\\\", \\\"genbankproteinaccession\\\", \\\"genesymbol\\\") # convert protein GIs to gene symbols. keys are mouse protein GIs, values are mouse gene symbols\\n print(missSymbolD)\\n\\n \\n for i in range(len(missIDL)):\\n if missL[i] in missNameL: procD[missIDL[i]] = {missL[i]: [missSymbolD[missGIL[missNameL.index(missL[i])]]]} \\n \\n mouseGeneL = []\\n for keyS in procD.keys():\\n for valueL in procD[keyS].values(): \\n if valueL == [\\\"-\\\"]: continue\\n for valueI in valueL:\\n if valueI in mouseGeneL: continue\\n mouseGeneL.append(valueI)\\n \\n mouseD = prot_id_converter(mouseGeneL, \\\"10090\\\", \\\"genesymbol\\\", \\\"geneid\\\")\\n \\n with file_importer(\\\"data/converted_gene_list.csv\\\", \\\"w\\\") as outF:\\n for keyS in procD.keys():\\n outF.write(keyS + \\\",\\\")\\n for keyN, valueN in procD[keyS].items():\\n outF.write(keyN + \\\",\\\")\\n if keyN == \\\"-\\\":\\n outF.write(\\\"-,-\\\\n\\\")\\n continue\\n valL = []\\n for valueI in valueN:\\n if valueI in mouseD: valL.append(mouseD[valueI])\\n else: valL.append(\\\"-\\\")\\n \\n if valueI is valueN[-1]: outF.write(valueI + \\\",\\\")\\n else: outF.write(valueI + \\\";\\\")\\n \\n for valI in valL:\\n if valI is valL[-1]: \\n if \\\"//\\\" in valI: \\n valIL = valI.split(\\\"//\\\")\\n for valILI in valIL:\\n if valILI is valIL[-1]: outF.write(valILI + \\\"\\\\n\\\")\\n else: outF.write(valILI + \\\";\\\")\\n else: outF.write(valI + \\\"\\\\n\\\")\\n \\n else: \\n if \\\"//\\\" in valI: \\n valIL = valI.split(\\\"//\\\")\\n for valILI in valIL:\\n outF.write(valILI + \\\";\\\")\\n else: outF.write(valI + \\\";\\\")\\n print(\\\"file written\\\")\",\n \"def test_different_units(self):\\n self.temperature.convert_units(\\\"celsius\\\")\\n self.relative_humidity.convert_units(\\\"1\\\")\\n self.pressure.convert_units(\\\"kPa\\\")\\n result = WetBulbTemperature().create_wet_bulb_temperature_cube(\\n self.temperature, self.relative_humidity, self.pressure\\n )\\n self.assertArrayAlmostEqual(result.data, self.expected_wbt_data, decimal=3)\\n self.assertEqual(result.units, Unit(\\\"K\\\"))\",\n \"def convert_H_kJmol(en_H):\\n return en_H/kJmol_H\",\n \"def test_convert_from_hpascals():\\n hpascals = 1000\\n assert pressure_util.convert(hpascals, PRESSURE_HPA, PRESSURE_PSI) == pytest.approx(\\n 14.5037743897\\n )\\n assert pressure_util.convert(\\n hpascals, PRESSURE_HPA, PRESSURE_INHG\\n ) == pytest.approx(29.5299801647)\\n assert pressure_util.convert(hpascals, PRESSURE_HPA, PRESSURE_PA) == pytest.approx(\\n 100000\\n )\\n assert pressure_util.convert(\\n hpascals, PRESSURE_HPA, PRESSURE_MBAR\\n ) == pytest.approx(1000)\",\n \"def test_genbank_to_genome_taxonomy(self):\\n result = self.gfu.genbank_to_genome(self.ctx, {\\n 'workspace_name': self.ws_name,\\n 'generate_ids_if_needed': 'true', # why is this a string\\n 'taxon_id': '3702',\\n 'file': {\\n 'path': f\\\"{_DATA_PATH}/wigglesworthia/genome.gb\\\"\\n },\\n 'genome_name': str(uuid4()),\\n })\\n ('result', result)\\n ref = result[0]['genome_ref']\\n self.assertTrue(ref, 'Genome ref exists')\\n info = result[0]['genome_info']\\n typ = info[2]\\n self.assertTrue(typ.startswith('KBaseGenomes.Genome'))\\n info_details = info[-1]\\n self.assertEqual(info_details['Taxonomy'], (\\n \\\"cellular organisms;Eukaryota;Viridiplantae;\\\"\\n \\\"Streptophyta;Streptophytina;Embryophyta;Tracheophyta;\\\"\\n \\\"Euphyllophyta;Spermatophyta;Magnoliopsida;Mesangiospermae;\\\"\\n \\\"eudicotyledons;Gunneridae;Pentapetalae;rosids;malvids;\\\"\\n \\\"Brassicales;Brassicaceae;Camelineae;Arabidopsis\\\"\\n ))\\n self.assertEqual(info_details['Size'], '697724')\\n self.assertEqual(info_details['Source'], 'Genbank')\\n self.assertEqual(info_details['Name'], 'Wigglesworthia glossinidia endosymbiont of Glossina brevipalpis')\\n self.assertEqual(info_details['GC content'], '0.22479')\\n self.assertEqual(info_details['Genetic code'], '11')\\n self.assertEqual(info_details['Number of Genome Level Warnings'], '1')\\n self.assertEqual(info_details['Source ID'], 'BA000021')\\n self.assertEqual(info_details['Number of Protein Encoding Genes'], '20')\\n self.assertEqual(info_details['Domain'], 'Eukaryota')\\n self.assertTrue(info_details['Assembly Object'])\\n self.assertEqual(info_details['Number contigs'], '1')\\n self.assertEqual(info_details['Number of CDS'], '20')\\n self.assertTrue(info_details['MD5'])\",\n \"def convert_units(array, in_units=\\\"None\\\"):\\n if in_units == \\\"None\\\" or in_units is None:\\n return array\\n else:\\n raise Exception(\\\"Unsupported unit for bispectrum descriptors.\\\")\",\n \"def get_quantity( self, species, quantity ) :\\n\\n #NB (for developers): this is a very simple implementation\\n #one must take care of the order of search of particle quantities\\n #'ux','uy','uz' etc. so that the routine effectively works by just\\n #using the replace method on strings. In addition, double character\\n #quantities containing other quantitities (e.g 'ex' contains 'x')\\n #are replaced with numbered quantities 'e1' to avoid collisions\\n #with replace().\\n\\n dict_keys_val=dict()\\n if \\\"ux\\\" in quantity :\\n dict_keys_val[\\\"u1\\\"]=species.getux(gather=False)\\n quantity=quantity.replace(\\\"ux\\\",\\\"u1\\\")\\n if \\\"uy\\\" in quantity :\\n dict_keys_val[\\\"u2\\\"]=species.getuy(gather=False)\\n quantity=quantity.replace(\\\"uy\\\",\\\"u2\\\")\\n if \\\"uz\\\" in quantity :\\n dict_keys_val[\\\"u3\\\"]=species.getuz(gather=False)\\n quantity=quantity.replace(\\\"uz\\\",\\\"u3\\\")\\n if \\\"ex\\\" in quantity :\\n dict_keys_val[\\\"e1\\\"]=species.getex(gather=False)\\n quantity=quantity.replace(\\\"ex\\\",\\\"e1\\\")\\n if \\\"ey\\\" in quantity :\\n dict_keys_val[\\\"e2\\\"]=species.getey(gather=False)\\n quantity=quantity.replace(\\\"ey\\\",\\\"e2\\\")\\n if \\\"ez\\\" in quantity :\\n dict_keys_val[\\\"e3\\\"]=species.getez(gather=False)\\n quantity=quantity.replace(\\\"ez\\\",\\\"e3\\\")\\n if \\\"bx\\\" in quantity :\\n dict_keys_val[\\\"b1\\\"]=species.getbx(gather=False)\\n quantity=quantity.replace(\\\"bx\\\",\\\"b1\\\")\\n if \\\"by\\\" in quantity :\\n dict_keys_val[\\\"b2\\\"]=species.getby(gather=False)\\n quantity=quantity.replace(\\\"by\\\",\\\"b2\\\")\\n if \\\"bz\\\" in quantity :\\n dict_keys_val[\\\"b3\\\"]=species.getbz(gather=False)\\n quantity=quantity.replace(\\\"bz\\\",\\\"b3\\\")\\n if \\\"w\\\" in quantity :\\n dict_keys_val[\\\"w\\\"]=species.getweights(gather=False)\\n if \\\"x\\\" in quantity :\\n dict_keys_val[\\\"x\\\"]=species.getx(gather=False)\\n if \\\"y\\\" in quantity :\\n dict_keys_val[\\\"y\\\"]=species.gety(gather=False)\\n if \\\"z\\\" in quantity :\\n dict_keys_val[\\\"z\\\"]=species.getz(gather=False)\\n if \\\"id\\\" in quantity:\\n # The ssnid is stored in Warp as a float. Thus, it needs\\n # to be converted to the nearest integer (rint)\\n dict_keys_val[\\\"id\\\"] = \\\\\\n (np.rint( species.getssn(gather=False) )).astype('uint64')\\n\\n string_to_exec=quantity\\n for keys in dict_keys_val.keys():\\n string_to_exec=string_to_exec.replace(keys,\\\"dict_keys_val[\\\\'\\\"+keys+\\\"\\\\']\\\")\\n string_to_exec='quantity_array = '+string_to_exec\\n local_dict = {'dict_keys_val':dict_keys_val, 'quantity_array':None}\\n exec(string_to_exec, globals(), local_dict)\\n\\n return( local_dict['quantity_array'] )\",\n \"def units(self, x):\\n u = ''.join([chr(d) for d in self[x]['units'][:]])\\n if (u in ['n/a']) and (x in ['latitude', 'longitude']):\\n u = 'radian' # assume radians\\n return u\",\n \"def test_number(self):\\n descriptor = clone(SPECIES_OBSERVATION_SCHEMA)\\n record = {\\n 'Observation Date': \\\"18/08/2016\\\",\\n 'Latitude': -32,\\n 'Longitude': 115,\\n 'Species Name': 1234\\n }\\n schema = SpeciesObservationSchema(descriptor)\\n with self.assertRaises(Exception):\\n schema.cast_species_name(record)\",\n \"def test_saturation_mixing_ratio_dimensions():\\n p = 998. * units.mbar\\n temp = 20 * units.celsius\\n assert str(saturation_mixing_ratio(p, temp).units) == 'dimensionless'\",\n \"def test_change_units(self):\\n s = State(\\\"water\\\", T=Q_(100, \\\"degC\\\"), p=Q_(1.0, \\\"atm\\\"), units=\\\"EE\\\")\\n assert s.units == \\\"EE\\\"\\n s.units = \\\"SI\\\"\\n assert s.units == \\\"SI\\\"\\n assert s.cv.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.cp.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.s.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.h.units == \\\"kilojoule / kilogram\\\"\\n assert s.T.units == \\\"degree_Celsius\\\"\\n assert s.u.units == \\\"kilojoule / kilogram\\\"\\n assert s.v.units == \\\"meter ** 3 / kilogram\\\"\\n assert s.p.units == \\\"bar\\\"\",\n \"def cast_tech(self):\\n # type: () -> string_types\\n return self._cast_tech\",\n \"def to(self, unit, equivalencies=[], freq=None):\\n\\n if not isinstance(unit, u.Unit):\\n unit = u.Unit(unit)\\n\\n if unit == self.unit:\\n # No copying\\n return self\\n\\n if ((self.unit.is_equivalent(u.Jy / u.beam) and\\n not any({u.Jy/u.beam, u.K}.issubset(set(eq)) for eq in equivalencies))):\\n # the 'not any' above checks that there is not already a defined\\n # Jy<->K equivalency. If there is, the code below is redundant\\n # and will cause problems.\\n\\n if hasattr(self, 'beams'):\\n factor = (self.jtok_factors(equivalencies=equivalencies) *\\n (self.unit*u.beam).to(u.Jy))\\n else:\\n # replace \\\"beam\\\" with the actual beam\\n if not hasattr(self, 'beam'):\\n raise ValueError(\\\"To convert objects with Jy/beam units, \\\"\\n \\\"the object needs to have a beam defined.\\\")\\n brightness_unit = self.unit * u.beam\\n\\n # create a beam equivalency for brightness temperature\\n if freq is None:\\n try:\\n freq = self.with_spectral_unit(u.Hz).spectral_axis\\n except AttributeError:\\n raise TypeError(\\\"Object of type {0} has no spectral \\\"\\n \\\"information. `freq` must be provided for\\\"\\n \\\" unit conversion from Jy/beam\\\"\\n .format(type(self)))\\n else:\\n if not freq.unit.is_equivalent(u.Hz):\\n raise u.UnitsError(\\\"freq must be given in equivalent \\\"\\n \\\"frequency units.\\\")\\n\\n bmequiv = self.beam.jtok_equiv(freq)\\n # backport to handle astropy < 3: the beam equivalency was only\\n # modified to handle jy/beam in astropy 3\\n if bmequiv[0] == u.Jy:\\n bmequiv.append([u.Jy/u.beam, u.K, bmequiv[2], bmequiv[3]])\\n\\n factor = brightness_unit.to(unit,\\n equivalencies=bmequiv + list(equivalencies))\\n\\n else:\\n # scaling factor\\n factor = self.unit.to(unit, equivalencies=equivalencies)\\n\\n converted_array = (self.quantity * factor).value\\n\\n # use private versions of variables, not the generated property\\n # versions\\n # Not entirely sure the use of __class__ here is kosher, but we do want\\n # self.__class__, not super()\\n new = self.__class__(value=converted_array, unit=unit, copy=True,\\n wcs=self._wcs, meta=self._meta, mask=self._mask,\\n header=self._header)\\n\\n return new\",\n \"def testRichness(self):\\n self.assertEqual(1184, self.tree.get_species_richness(1))\\n self.assertEqual(1677, self.tree.get_species_richness(2))\",\n \"def units_to_fits(unit):\\n if unit is None:\\n unit = Unit('')\\n return unit.to_string(\\\"fits\\\").upper()\",\n \"def _format_numbers(smth: any) -> any:\\n if isinstance(smth, int):\\n return float(smth)\\n elif smth == 'N.V.':\\n return 0.0 # meaning, wine is of type 'non-vintage' and is made of grapes from more than one harvest\\n else:\\n return smth\",\n \"def testRichness(self):\\n self.assertEqual(279, self.tree.get_species_richness(1))\\n self.assertEqual(281, self.tree.get_species_richness(2))\",\n \"def convert(self):\\n return _libsbml.SBMLUnitsConverter_convert(self)\",\n \"def get_units(self,):\\n self.UNITS = {'pressure':'Pa',}\\n return\",\n \"def FeatureValueFormat(singlegene):\\n comp_exon = np.zeros((len(singlegene['exons']),), dtype=np.object)\\n for i in range(len(singlegene['exons'])):\\n comp_exon[i]= np.array(singlegene['exons'][i])\\n singlegene['exons'] = comp_exon\\n comp_cds = np.zeros((len(singlegene['cds_exons']),), dtype=np.object)\\n for i in range(len(singlegene['cds_exons'])):\\n comp_cds[i]= np.array(singlegene['cds_exons'][i])\\n singlegene['cds_exons'] = comp_cds\\n comp_utr3 = np.zeros((len(singlegene['utr3_exons']),), dtype=np.object)\\n for i in range(len(singlegene['utr3_exons'])):\\n comp_utr3[i]= np.array(singlegene['utr3_exons'][i])\\n singlegene['utr3_exons'] = comp_utr3\\n comp_utr5 = np.zeros((len(singlegene['utr5_exons']),), dtype=np.object)\\n for i in range(len(singlegene['utr5_exons'])):\\n comp_utr5[i]= np.array(singlegene['utr5_exons'][i])\\n singlegene['utr5_exons'] = comp_utr5\\n comp_transcripts = np.zeros((len(singlegene['transcripts']),), dtype=np.object)\\n for i in range(len(singlegene['transcripts'])):\\n comp_transcripts[i]= np.array(singlegene['transcripts'][i])\\n singlegene['transcripts'] = comp_transcripts\\n comp_tss = np.zeros((len(singlegene['tss']),), dtype=np.object)\\n for i in range(len(singlegene['tss'])):\\n comp_tss[i]= np.array(singlegene['tss'][i])\\n singlegene['tss'] = comp_tss\\n comp_tis = np.zeros((len(singlegene['tis']),), dtype=np.object)\\n for i in range(len(singlegene['tis'])):\\n comp_tis[i]= np.array(singlegene['tis'][i])\\n singlegene['tis'] = comp_tis\\n comp_cleave = np.zeros((len(singlegene['cleave']),), dtype=np.object)\\n for i in range(len(singlegene['cleave'])):\\n comp_cleave[i]= np.array(singlegene['cleave'][i])\\n singlegene['cleave'] = comp_cleave\\n comp_cdsStop = np.zeros((len(singlegene['cdsStop']),), dtype=np.object)\\n for i in range(len(singlegene['cdsStop'])):\\n comp_cdsStop[i]= np.array(singlegene['cdsStop'][i])\\n singlegene['cdsStop'] = comp_cdsStop\\n\\n return singlegene\",\n \"def serotype_escherichia(metadata, analysistype):\\n for sample in metadata:\\n # Initialise negative results to be overwritten when necessary\\n sample[analysistype].best_o_pid = '-'\\n sample[analysistype].o_genes = ['-']\\n sample[analysistype].o_set = ['-']\\n sample[analysistype].best_h_pid = '-'\\n sample[analysistype].h_genes = ['-']\\n sample[analysistype].h_set = ['-']\\n if sample.general.bestassemblyfile != 'NA':\\n if sample.general.closestrefseqgenus in ['Escherichia', 'Shigella']:\\n o = dict()\\n h = dict()\\n for result, percentid in sample[analysistype].blastresults.items():\\n if 'O' in result.split('_')[-1]:\\n o.update({result: float(percentid)})\\n if 'H' in result.split('_')[-1]:\\n h.update({result: float(percentid)})\\n # O\\n try:\\n sorted_o = sorted(o.items(), key=operator.itemgetter(1), reverse=True)\\n sample[analysistype].best_o_pid = str(sorted_o[0][1])\\n\\n sample[analysistype].o_genes = [gene for gene, pid in o.items()\\n if str(pid) == sample[analysistype].best_o_pid]\\n sample[analysistype].o_set = \\\\\\n list(set(gene.split('_')[-1] for gene in sample[analysistype].o_genes))\\n except (KeyError, IndexError):\\n pass\\n # H\\n try:\\n sorted_h = sorted(h.items(), key=operator.itemgetter(1), reverse=True)\\n sample[analysistype].best_h_pid = str(sorted_h[0][1])\\n sample[analysistype].h_genes = [gene for gene, pid in h.items()\\n if str(pid) == sample[analysistype].best_h_pid]\\n sample[analysistype].h_set = \\\\\\n list(set(gene.split('_')[-1] for gene in sample[analysistype].h_genes))\\n except (KeyError, IndexError):\\n pass\\n return metadata\",\n \"def convert_units(celsius_value, units):\\n if units == 0:\\n return celsius_value\\n if units == 1:\\n return celsius_value * 1.8 + 32\\n return celsius_value + 273.15\",\n \"def test_species_to_sdf_file(self):\\n path = os.path.join(ARC_PATH, 'arc', 'testing', 'mol.sdf')\\n spc = ARCSpecies(label='NCC', smiles='NCC')\\n converter.species_to_sdf_file(spc, path)\\n with open(path, 'r') as f:\\n sdf_content = f.read()\\n expected_sdf = \\\"\\\"\\\"\\n RDKit 3D\\n\\n 10 9 0 0 0 0 0 0 0 0999 V2000\\n 1.1517 -0.3760 -0.5231 N 0 0 0 0 0 0 0 0 0 0 0 0\\n 0.2893 0.4500 0.3115 C 0 0 0 0 0 0 0 0 0 0 0 0\\n -1.1415 -0.0561 0.2592 C 0 0 0 0 0 0 0 0 0 0 0 0\\n 1.1386 -1.3376 -0.1854 H 0 0 0 0 0 0 0 0 0 0 0 0\\n 2.1151 -0.0555 -0.4352 H 0 0 0 0 0 0 0 0 0 0 0 0\\n 0.6517 0.4342 1.3447 H 0 0 0 0 0 0 0 0 0 0 0 0\\n 0.3279 1.4855 -0.0414 H 0 0 0 0 0 0 0 0 0 0 0 0\\n -1.2133 -1.0839 0.6308 H 0 0 0 0 0 0 0 0 0 0 0 0\\n -1.7870 0.5726 0.8809 H 0 0 0 0 0 0 0 0 0 0 0 0\\n -1.5327 -0.0332 -0.7636 H 0 0 0 0 0 0 0 0 0 0 0 0\\n 1 2 1 0\\n 1 4 1 0\\n 1 5 1 0\\n 2 3 1 0\\n 2 6 1 0\\n 2 7 1 0\\n 3 8 1 0\\n 3 9 1 0\\n 3 10 1 0\\nM END\\n$$$$\\n\\\"\\\"\\\"\\n self.assertEqual(sdf_content, expected_sdf)\",\n \"def test_human_ens_to_sym(self):\\n\\n mapper = EnsemblMapper(\\n from_type='ensembl', to_type='symbol', host=HOST)\\n mapped = mapper.map_ids(['ENSG00000141510', 'ENSG00000012048'])\\n\\n assert mapped == ['TP53', 'BRCA1']\",\n \"def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)\",\n \"def isSetUnits(self):\\n return _libsbml.Species_isSetUnits(self)\",\n \"def add_special_conversion(self, from_units, to_units, converter):\\n self.special_conversions[(from_units, to_units)] = converter\",\n \"def test_size_topping(self):\\n formatted_name = get_formatted_name('jimi', 'hendrix')\\n self.assertEqual(formatted_name, 'Jimi Hendrix')\",\n \"def fix_coord_units(cat, RA, DEC):\\n cat[RA].info.unit = u.deg\\n cat[DEC].info.unit = u.deg\\n return cat\",\n \"def test_unit_conversion_incompatible(self):\\n self.orography_cube.units = 'K'\\n msg = \\\"Unable to convert from\\\"\\n with self.assertRaisesRegex(ValueError, msg):\\n self.plugin_instance.process(self.orography_cube)\",\n \"def test_conversions(self):\\n\\n coord_cart_single = np.array([1, 2])\\n coord_homo_single = np.array([1, 2, 1])\\n coord_cart_multiple = np.array([[1.5, 2.], [2.3, 10.], [11., 18.]])\\n coord_homo_multiple = np.array([[1.5, 2., 1.], [2.3, 10., 1.], [11., 18., 1.]])\\n\\n # Test the single coordinate case\\n self.assertTrue(np.allclose(po.cart2homo(coord_cart_single), coord_homo_single))\\n self.assertTrue(np.allclose(po.homo2cart(coord_homo_single), coord_cart_single))\\n # Test the multiple coordinate case\\n self.assertTrue(np.allclose(po.cart2homo(coord_cart_multiple), coord_homo_multiple))\\n self.assertTrue(np.allclose(po.homo2cart(coord_homo_multiple), coord_cart_multiple))\",\n \"def _IsAngstroem(units):\\n if isinstance(units, Atom):\\n check = units.store.get(\\\"units\\\")\\n if not check:\\n return False\\n else:\\n check = units\\n return check == \\\"angstroem\\\" or check == \\\"angstroemd0\\\"\",\n \"def to_isotropic(self) -> None:\\n self.uvals = [0.04, 0.0, 0.0, 0.0, 0.0, 0.0]\",\n \"def test_rmg_mol_from_inchi(self):\\n mol1 = converter.rmg_mol_from_inchi('InChI=1S/NO2/c2-1-3')\\n mol2 = converter.rmg_mol_from_inchi('InChI=1/CH3NOS/c1-2-3-4-1/h2H,1H2')\\n\\n self.assertTrue(isinstance(mol1, Molecule))\\n self.assertTrue(isinstance(mol2, Molecule))\\n\\n self.assertEqual(mol1.to_smiles(), '[O]N=O')\\n self.assertEqual(mol2.to_smiles(), 'C1NOS1')\",\n \"def testRichness(self):\\n self.assertEqual(2587, self.tree.get_species_richness(1))\\n self.assertEqual(3087, self.tree.get_species_richness(2))\",\n \"def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\\n return process_unit_input(value, units, convert=True, registry=registry).v\",\n \"def test_to_from_iupac(self):\\n from openff.toolkit.utils.toolkits import (\\n InvalidIUPACNameError,\\n UndefinedStereochemistryError,\\n )\\n\\n with pytest.raises(InvalidIUPACNameError):\\n Molecule.from_iupac(\\\".BETA.-PINENE\\\")\\n\\n # DrugBank_977, tagged as a problem molecule in earlier tests\\n bad_stereo_iupac = (\\n \\\"(~{E},3~{R},5~{S})-7-[4-(4-fluorophenyl)-6-isopropyl-2-\\\"\\n \\\"[methyl(methylsulfonyl)amino]pyrimidin-5-yl]-3,5-\\\"\\n \\\"dihydroxy-hept-6-enoic acid\\\"\\n )\\n with pytest.raises(UndefinedStereochemistryError):\\n Molecule.from_iupac(bad_stereo_iupac)\\n\\n cholesterol = Molecule.from_smiles(\\n \\\"C[C@H](CCCC(C)C)[C@H]1CC[C@@H]2[C@@]1(CC[C@H]3[C@H]2CC=C4[C@@]3(CC[C@@H](C4)O)C)C\\\"\\n )\\n\\n cholesterol_iupac = cholesterol.to_iupac()\\n\\n assert Molecule.are_isomorphic(\\n cholesterol, Molecule.from_iupac(cholesterol_iupac)\\n )\",\n \"def testRichness(self):\\n self.assertEqual(3460, self.tree.get_species_richness(1))\\n self.assertEqual(3613, self.tree.get_species_richness(2))\",\n \"def test_set_su(self):\\n s = State(substance=\\\"water\\\")\\n s.su = Q_(3028.9867985920914, \\\"J/(kg*K)\\\"), Q_(1013250.0, \\\"J/kg\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(373.1242958476843, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.su[0], Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.su[1], Q_(1013250.0, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(1013250, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(3028.9867985920914, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(0.4772010021515822, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(1061602.391543017, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.x, Q_(0.28475636946248034, \\\"dimensionless\\\")) # type: ignore\",\n \"def from_sony(self):\\n reason = \\\"[!] Sonyflake values are 15 hex characters\\\"\\n ts_type = self.ts_types['sony']\\n try:\\n if len(str(self.sony)) != 15 or not all(char in hexdigits for char in self.sony):\\n self.in_sony = indiv_output = combined_output = False\\n pass\\n else:\\n dec_value = int(self.sony, 16)\\n ts_value = dec_value >> 24\\n unix_ts = (ts_value + 140952960000) * 10\\n self.in_sony = dt.utcfromtimestamp(float(unix_ts) /1000.0).strftime('%Y-%m-%d %H:%M:%S.%f')\\n indiv_output = str(\\\"{} {}\\\".format(ts_type, self.in_sony))\\n combined_output = str(\\\"{}{}\\\\t\\\\t\\\\t{} UTC{}\\\".format(self.left_color, ts_type, self.in_sony, self.right_color))\\n except Exception:\\n exc_type, exc_obj, exc_tb = sys.exc_info()\\n print(str(exc_type) + \\\" - \\\" + str(exc_obj) + \\\" - line \\\" + str(exc_tb.tb_lineno))\\n self.in_sony = indiv_output = combined_output = False\\n return self.in_sony, indiv_output, combined_output, reason\",\n \"def unit_conversion(thing, units, length=False):\\n if 'n/a' == thing:\\n return 'n/a'\\n try:\\n thing = round(thing * CONVERSION[units][0 + length], 2)\\n except:\\n thing = 'fubar'\\n return thing, CONVERSION[units][2 + length]\",\n \"def _celsius_to_fahrenheit(self) -> None:\\n if self.units == \\\"celsius\\\":\\n self.value = (((self.value / 5) * 9) + 32).__round__(2)\\n self.units = \\\"fahrenheit\\\"\\n else:\\n msg = (\\n \\\"Not a valid unit conversion, expected units to be in 'celsius' but instead \\\"\\n + f\\\"units were in {self.units}.\\\"\\n )\\n raise ValueError(msg)\",\n \"def createPossibleSpeciesFeatureValue(self):\\n return _libsbml.SpeciesFeatureType_createPossibleSpeciesFeatureValue(self)\",\n \"def testFtoCValues(self):\\r\\n for c,f in self.knownConversionsCtoF:\\r\\n result = conversions.convertFahrenheittoCelsius(f)\\r\\n self.assertEqual(c,result)\",\n \"def setUp(self):\\n self.nC4H10O = Species(\\n label='n-C4H10O',\\n conformer=Conformer(\\n E0=(-317.807, 'kJ/mol'),\\n modes=[\\n IdealGasTranslation(mass=(74.07, \\\"g/mol\\\")),\\n NonlinearRotor(inertia=([41.5091, 215.751, 233.258], \\\"amu*angstrom^2\\\"), symmetry=1),\\n HarmonicOscillator(frequencies=(\\n [240.915, 341.933, 500.066, 728.41, 809.987, 833.93, 926.308, 948.571, 1009.3, 1031.46, 1076,\\n 1118.4, 1184.66, 1251.36, 1314.36, 1321.42, 1381.17, 1396.5, 1400.54, 1448.08, 1480.18, 1485.34,\\n 1492.24, 1494.99, 1586.16, 2949.01, 2963.03, 2986.19, 2988.1, 2995.27, 3026.03, 3049.05, 3053.47,\\n 3054.83, 3778.88], \\\"cm^-1\\\")),\\n HinderedRotor(inertia=(0.854054, \\\"amu*angstrom^2\\\"), symmetry=1, fourier=(\\n [[0.25183, -1.37378, -2.8379, 0.0305112, 0.0028088],\\n [0.458307, 0.542121, -0.599366, -0.00283925, 0.0398529]], \\\"kJ/mol\\\")),\\n HinderedRotor(inertia=(8.79408, \\\"amu*angstrom^2\\\"), symmetry=1, fourier=(\\n [[0.26871, -0.59533, -8.15002, -0.294325, -0.145357],\\n [1.1884, 0.99479, -0.940416, -0.186538, 0.0309834]], \\\"kJ/mol\\\")),\\n HinderedRotor(inertia=(7.88153, \\\"amu*angstrom^2\\\"), symmetry=1, fourier=(\\n [[-4.67373, 2.03735, -6.25993, -0.27325, -0.048748],\\n [-0.982845, 1.76637, -1.57619, 0.474364, -0.000681718]], \\\"kJ/mol\\\")),\\n HinderedRotor(inertia=(2.81525, \\\"amu*angstrom^2\\\"), symmetry=3, barrier=(2.96807, \\\"kcal/mol\\\")),\\n ],\\n spin_multiplicity=1,\\n optical_isomers=1,\\n ),\\n molecular_weight=(74.07, \\\"g/mol\\\"),\\n transport_data=TransportData(sigma=(5.94, 'angstrom'), epsilon=(559, 'K')),\\n energy_transfer_model=SingleExponentialDown(alpha0=(447.5 * 0.011962, \\\"kJ/mol\\\"), T0=(300, \\\"K\\\"), n=0.85),\\n )\\n\\n self.nC4H10O.from_smiles('CCCCO')\\n\\n self.nC4H8 = Species(\\n label='n-C4H8',\\n conformer=Conformer(\\n E0=(-17.8832, 'kJ/mol'),\\n modes=[\\n IdealGasTranslation(mass=(56.06, \\\"g/mol\\\")),\\n NonlinearRotor(inertia=([22.2748, 122.4, 125.198], \\\"amu*angstrom^2\\\"), symmetry=1),\\n HarmonicOscillator(frequencies=(\\n [308.537, 418.67, 636.246, 788.665, 848.906, 936.762, 979.97, 1009.48, 1024.22, 1082.96, 1186.38,\\n 1277.55, 1307.65, 1332.87, 1396.67, 1439.09, 1469.71, 1484.45, 1493.19, 1691.49, 2972.12, 2994.31,\\n 3018.48, 3056.87, 3062.76, 3079.38, 3093.54, 3174.52], \\\"cm^-1\\\")),\\n HinderedRotor(inertia=(5.28338, \\\"amu*angstrom^2\\\"), symmetry=1, fourier=(\\n [[-0.579364, -0.28241, -4.46469, 0.143368, 0.126756],\\n [1.01804, -0.494628, -0.00318651, -0.245289, 0.193728]], \\\"kJ/mol\\\")),\\n HinderedRotor(inertia=(2.60818, \\\"amu*angstrom^2\\\"), symmetry=3, fourier=(\\n [[0.0400372, 0.0301986, -6.4787, -0.0248675, -0.0324753],\\n [0.0312541, 0.0538, -0.493785, 0.0965968, 0.125292]], \\\"kJ/mol\\\")),\\n ],\\n spin_multiplicity=1,\\n optical_isomers=1,\\n ),\\n )\\n\\n self.nC4H8.from_smiles('CCC=C')\\n\\n self.H2O = Species(\\n label='H2O',\\n conformer=Conformer(\\n E0=(-269.598, 'kJ/mol'),\\n modes=[\\n IdealGasTranslation(mass=(18.01, \\\"g/mol\\\")),\\n NonlinearRotor(inertia=([0.630578, 1.15529, 1.78586], \\\"amu*angstrom^2\\\"), symmetry=2),\\n HarmonicOscillator(frequencies=([1622.09, 3771.85, 3867.85], \\\"cm^-1\\\")),\\n ],\\n spin_multiplicity=1,\\n optical_isomers=1,\\n ),\\n )\\n\\n self.H2O.from_smiles('O')\\n\\n self.N2 = Species(\\n label='N2',\\n molecular_weight=(28.04, \\\"g/mol\\\"),\\n transport_data=TransportData(sigma=(3.41, \\\"angstrom\\\"), epsilon=(124, \\\"K\\\")),\\n energy_transfer_model=None,\\n )\\n\\n self.N2.from_smiles('N#N')\\n\\n logging.error('to TS')\\n\\n self.TS = TransitionState(\\n label='TS',\\n conformer=Conformer(\\n E0=(-42.4373, \\\"kJ/mol\\\"),\\n modes=[\\n IdealGasTranslation(mass=(74.07, \\\"g/mol\\\")),\\n NonlinearRotor(inertia=([40.518, 232.666, 246.092], \\\"u*angstrom**2\\\"), symmetry=1, quantum=False),\\n HarmonicOscillator(frequencies=(\\n [134.289, 302.326, 351.792, 407.986, 443.419, 583.988, 699.001, 766.1, 777.969, 829.671, 949.753,\\n 994.731, 1013.59, 1073.98, 1103.79, 1171.89, 1225.91, 1280.67, 1335.08, 1373.9, 1392.32, 1417.43,\\n 1469.51, 1481.61, 1490.16, 1503.73, 1573.16, 2972.85, 2984.3, 3003.67, 3045.78, 3051.77, 3082.37,\\n 3090.44, 3190.73, 3708.52], \\\"kayser\\\")),\\n HinderedRotor(inertia=(2.68206, \\\"amu*angstrom^2\\\"), symmetry=3, barrier=(3.35244, \\\"kcal/mol\\\")),\\n HinderedRotor(inertia=(9.77669, \\\"amu*angstrom^2\\\"), symmetry=1, fourier=(\\n [[0.208938, -1.55291, -4.05398, -0.105798, -0.104752],\\n [2.00518, -0.020767, -0.333595, 0.137791, -0.274578]], \\\"kJ/mol\\\")),\\n ],\\n spin_multiplicity=1,\\n optical_isomers=1,\\n ),\\n frequency=(-2038.34, 'cm^-1'),\\n )\\n\\n self.reaction = Reaction(\\n label='dehydration',\\n reactants=[self.nC4H10O],\\n products=[self.nC4H8, self.H2O],\\n transition_state=self.TS,\\n kinetics=Arrhenius(A=(0.0387, 'm^3/(mol*s)'), n=2.7, Ea=(2.6192e4, 'J/mol'), T0=(1, 'K'))\\n )\\n\\n self.network = Network(\\n label='n-butanol',\\n isomers=[Configuration(self.nC4H10O)],\\n reactants=[],\\n products=[Configuration(self.nC4H8, self.H2O)],\\n path_reactions=[self.reaction],\\n bath_gas={self.N2: 1.0},\\n )\\n\\n self.pdepnetwork = deepcopy(self.network)\\n self.pdepnetwork.__class__ = PDepNetwork\\n self.pdepnetwork.source = [self.pdepnetwork.isomers[0].species[0]]\\n self.pdepnetwork.index = 1\\n self.pdepnetwork.explored = []\",\n \"def test_inches_valid(self):\\n result = inch_to_cm(\\\"72\\\\\\\"\\\")\\n self.assertEqual(result, 183)\",\n \"def _mps_to_mph(self) -> None:\\n if self.units == \\\"m/s\\\":\\n self.units = \\\"mph\\\"\\n self.value = (self.value * 2.236936).__round__(2)\\n else:\\n msg = (\\n \\\"Not a valid unit conversion, expected units to be in 'm/s' but instead \\\"\\n + f\\\"units were in {self.units}.\\\"\\n )\\n raise ValueError(msg)\",\n \"def convert_from_pj_player_species(pjp_species):\\n if not is_pj_player_species(pjp_species):\\n raise ValueError(\\\"convert_from_pj_player_species: Invalid PyJSON Player Species\\\")\\n\\n return convert_from_pj_los(pjp_species[1])\",\n \"def testRichness(self):\\n self.assertEqual(3359, self.tree.get_species_richness(1))\\n self.assertEqual(3468, self.tree.get_species_richness(2))\",\n \"def test_smiles_types(self, data, toolkit_class):\\n\\n if toolkit_class.is_available():\\n toolkit = toolkit_class()\\n mol = create_cis_1_2_dichloroethene()\\n isomeric, explicit_hs, mapped = (\\n data[\\\"isomeric\\\"],\\n data[\\\"explicit_hydrogens\\\"],\\n data[\\\"mapped\\\"],\\n )\\n if data[\\\"error\\\"] is not None:\\n with pytest.raises(data[\\\"error\\\"]):\\n mol.to_smiles(\\n isomeric=isomeric,\\n explicit_hydrogens=explicit_hs,\\n mapped=mapped,\\n toolkit_registry=toolkit,\\n )\\n\\n else:\\n # make the smiles then do some checks on it\\n output_smiles = mol.to_smiles(\\n isomeric=isomeric,\\n explicit_hydrogens=explicit_hs,\\n mapped=mapped,\\n toolkit_registry=toolkit,\\n )\\n if isomeric:\\n assert \\\"\\\\\\\\\\\" in output_smiles\\n if explicit_hs:\\n assert \\\"H\\\" in output_smiles\\n if mapped:\\n for i in range(1, 7):\\n assert f\\\":{i}\\\" in output_smiles\\n # if the molecule is mapped make it using the mapping\\n mol2 = Molecule.from_mapped_smiles(\\n mapped_smiles=output_smiles,\\n toolkit_registry=toolkit,\\n allow_undefined_stereo=not isomeric,\\n )\\n else:\\n # make a molecule from a standard smiles\\n mol2 = Molecule.from_smiles(\\n smiles=output_smiles,\\n allow_undefined_stereo=not isomeric,\\n toolkit_registry=toolkit,\\n )\\n\\n isomorphic, atom_map = Molecule.are_isomorphic(\\n mol,\\n mol2,\\n return_atom_map=True,\\n aromatic_matching=True,\\n formal_charge_matching=True,\\n bond_order_matching=True,\\n atom_stereochemistry_matching=isomeric,\\n bond_stereochemistry_matching=isomeric,\\n )\\n\\n assert isomorphic is True\\n if mapped:\\n assert {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5} == atom_map\\n\\n else:\\n pytest.skip(\\n f\\\"The required toolkit ({toolkit_class.toolkit_name}) is not available.\\\"\\n )\",\n \"def convert(x, unit1, unit2):\\r\\n return conversions[unit1][unit2](x)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57525384","0.57275754","0.5674095","0.5629548","0.5565156","0.55589813","0.5499987","0.5466268","0.54491645","0.5431514","0.5431423","0.54084706","0.54083174","0.5377826","0.5314006","0.5296716","0.5266335","0.5263386","0.52353054","0.5214933","0.52123255","0.5206657","0.51860654","0.5184395","0.5172464","0.5169806","0.5166909","0.5165196","0.5148753","0.5128592","0.5112237","0.50995797","0.50924903","0.50897634","0.50763947","0.50755554","0.50731725","0.50703186","0.50667405","0.5064373","0.5058494","0.5056412","0.505595","0.50555044","0.5037046","0.5032455","0.50285584","0.50282645","0.50264645","0.50197035","0.5016991","0.50138295","0.5011586","0.5008922","0.50034374","0.4998052","0.4993594","0.49826896","0.4980274","0.49607366","0.49570534","0.49551374","0.49546176","0.49536422","0.49523136","0.49345413","0.4934052","0.4933033","0.49308458","0.4928638","0.4915703","0.49062327","0.4902471","0.49021187","0.48976976","0.48916286","0.4883813","0.48790002","0.4877849","0.48611635","0.4860984","0.48593077","0.4859035","0.48579523","0.48549017","0.4854772","0.48547545","0.48538664","0.48489368","0.4848134","0.4844847","0.4844465","0.48412782","0.48395842","0.48378533","0.48362285","0.48345575","0.4830607","0.48179036","0.48177907"],"string":"[\n \"0.57525384\",\n \"0.57275754\",\n \"0.5674095\",\n \"0.5629548\",\n \"0.5565156\",\n \"0.55589813\",\n \"0.5499987\",\n \"0.5466268\",\n \"0.54491645\",\n \"0.5431514\",\n \"0.5431423\",\n \"0.54084706\",\n \"0.54083174\",\n \"0.5377826\",\n \"0.5314006\",\n \"0.5296716\",\n \"0.5266335\",\n \"0.5263386\",\n \"0.52353054\",\n \"0.5214933\",\n \"0.52123255\",\n \"0.5206657\",\n \"0.51860654\",\n \"0.5184395\",\n \"0.5172464\",\n \"0.5169806\",\n \"0.5166909\",\n \"0.5165196\",\n \"0.5148753\",\n \"0.5128592\",\n \"0.5112237\",\n \"0.50995797\",\n \"0.50924903\",\n \"0.50897634\",\n \"0.50763947\",\n \"0.50755554\",\n \"0.50731725\",\n \"0.50703186\",\n \"0.50667405\",\n \"0.5064373\",\n \"0.5058494\",\n \"0.5056412\",\n \"0.505595\",\n \"0.50555044\",\n \"0.5037046\",\n \"0.5032455\",\n \"0.50285584\",\n \"0.50282645\",\n \"0.50264645\",\n \"0.50197035\",\n \"0.5016991\",\n \"0.50138295\",\n \"0.5011586\",\n \"0.5008922\",\n \"0.50034374\",\n \"0.4998052\",\n \"0.4993594\",\n \"0.49826896\",\n \"0.4980274\",\n \"0.49607366\",\n \"0.49570534\",\n \"0.49551374\",\n \"0.49546176\",\n \"0.49536422\",\n \"0.49523136\",\n \"0.49345413\",\n \"0.4934052\",\n \"0.4933033\",\n \"0.49308458\",\n \"0.4928638\",\n \"0.4915703\",\n \"0.49062327\",\n \"0.4902471\",\n \"0.49021187\",\n \"0.48976976\",\n \"0.48916286\",\n \"0.4883813\",\n \"0.48790002\",\n \"0.4877849\",\n \"0.48611635\",\n \"0.4860984\",\n \"0.48593077\",\n \"0.4859035\",\n \"0.48579523\",\n \"0.48549017\",\n \"0.4854772\",\n \"0.48547545\",\n \"0.48538664\",\n \"0.48489368\",\n \"0.4848134\",\n \"0.4844847\",\n \"0.4844465\",\n \"0.48412782\",\n \"0.48395842\",\n \"0.48378533\",\n \"0.48362285\",\n \"0.48345575\",\n \"0.4830607\",\n \"0.48179036\",\n \"0.48177907\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.49707523"},"document_rank":{"kind":"string","value":"59"}}},{"rowIdx":14871,"cells":{"query":{"kind":"string","value":"Unit conversion with bad arguments raises errors."},"document":{"kind":"string","value":"def test_convert_unit_bad_args(test_pd_df):\n idf = IamDataFrame(test_pd_df).rename(unit={\"EJ/yr\": \"Mt CH4\"})\n\n # Conversion fails with both *factor* and *registry*\n with pytest.raises(ValueError, match=\"Use either `factor` or `registry`!\"):\n idf.convert_unit(\"Mt CH4\", \"CO2e\", factor=1.0, registry=object())\n\n # Conversion fails with an invalid registry\n with pytest.raises(TypeError, match=\"must be `pint.UnitRegistry`\"):\n idf.convert_unit(\"Mt CH4\", \"CO2e\", registry=object())\n\n # Conversion fails without context; exception provides a usage hint\n match = r\"GWP conversion with IamDataFrame.convert_unit\\(\\) requires...\"\n with pytest.raises(pint.UndefinedUnitError, match=match):\n idf.convert_unit(\"Mt CH4\", \"CO2e\")"},"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 convertUnit(*args, fromUnit: AnyStr=\"\", toUnit: AnyStr=\"\", **kwargs)->float:\n pass","def test_convert_invalid_unit():\n with pytest.raises(ValueError):\n pressure_util.convert(5, INVALID_SYMBOL, VALID_SYMBOL)\n\n with pytest.raises(ValueError):\n pressure_util.convert(5, VALID_SYMBOL, INVALID_SYMBOL)","def test_convert_incompatible_units(self):\n self.assertRaises(ValueError, convert_units, self.arr, 'm')","def test_convert_same_unit():\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5","def test_unit_conversion_incompatible(self):\n self.orography_cube.units = 'K'\n msg = \"Unable to convert from\"\n with self.assertRaisesRegex(ValueError, msg):\n self.plugin_instance.process(self.orography_cube)","def test_convert_nonnumeric_value():\n with pytest.raises(TypeError):\n pressure_util.convert(\"a\", PRESSURE_HPA, PRESSURE_INHG)","def try_convert(self, func, *args, **kwargs):\n try:\n func(*args, **kwargs)\n except UnitsError, e:\n if self.show_xml_context_only:\n e.show_xml_context_only()\n if self.warn_only:\n e.warn = True\n e.level = logging.WARNING\n logging.getLogger('units-converter').log(e.level, unicode(e).encode('UTF-8'))","def test_ms2min(self):\n result = TimeUnit(-50, 'ms', 'min')\n self.assertRaises(ValueError, lambda: result.doconvert())","def _convert_to_and_validate_distance_unit(unit):\n if unit is not None:\n unit = u.Unit(unit)\n\n if not unit.is_equivalent(u.kpc):\n raise u.UnitsError(six.u('Unit \"{0}\" is not a distance').format(unit))\n return unit","def convert_units(value, from_unit, to_unit, **args):\n\n # Check if units can be converted\n if not can_convert(from_unit, to_unit):\n return '[!] Units cannot be converted\\n'\n\n # Extract the numeric value from the string\n decimal_places = 2 # Set the default value of precision\n if \".\" in str(value):\n decimal_places = len(str(value)[str(value).index('.') + 1:])\n\n # Return the value if units are the same\n if from_unit == to_unit:\n return str(value) + \" \" + get_si(to_unit)\n\n responses = [\n check_time(value, from_unit, to_unit, decimal_places), # Time units\n check_metric_imperial(\n value,\n from_unit,\n to_unit,\n decimal_places), # Metric and Imperial units\n check_digital_storage(\n value,\n from_unit,\n to_unit,\n decimal_places\n ) # Digital storage units\n ]\n\n for response in responses:\n if response:\n return response\n\n # actually convert the units\n try:\n return str(round(convert(from_unit, to_unit, float(value), **args), decimal_places)) + \" \" + get_si(to_unit)\n except RequireAdditionalParamError as e:\n additional_unit = input(\"\\n[*] Enter an additional unit (choose between \" + str(e.additional_params) + \"): \")\n additional_value = float(input(\"\\n[*] Enter the value: \"))\n return convert_units(value, from_unit, to_unit, **{additional_unit: additional_value})\n except ConversionError as e:\n print(e.reason)","def test_as_type_invalid_cast(self, wrapped_unit: MyType) -> None:\n # Arrange.\n # Create a new fake UnitType.\n other_type = mock.MagicMock()\n # Give it a name for easier debugging.\n other_type.__name__ = \"OtherType\"\n\n # A fake unit to convert.\n to_convert = MyUnit(wrapped_unit, 10)\n\n # Act and assert.\n # Conversion should fail since no cast is registered.\n with pytest.raises(CastError):\n wrapped_unit.as_type(to_convert, other_type)","def test_wrongunit(self, a, b, rtol, atol):\n with pytest.raises(u.UnitsError):\n self.func(a, b, rtol, atol)","def Unit_convertToSI(*args):\n return _libsbml.Unit_convertToSI(*args)","def ensure_unit(arg, unit):\n if not isinstance(arg, u.Quantity):\n arg = arg * unit\n return arg.to(unit)","def describe_a_library_of_units_converters_that():\n def blows_smoke():\n assert True\n\n def can_convert_psi_to_kpa():\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\n\n # def can_convert_kpa_to_psi():\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\n\n # def can_convert_mpg_to_lp100k():\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\n\n # def can_convert_lp100k_to_mpg():\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg","def test_wk2yr(self):\n result = TimeUnit(-34, 'wk', 'yr')\n self.assertRaises(ValueError, lambda: result.doconvert())","def test_from_knx_wrong_parameter2(self):\n with self.assertRaises(ConversionError):\n DPTValue1Ucount().from_knx(\"0x23\")","def test_wrongunit(self, a, b, rtol, atol, expected):\n with pytest.raises(u.UnitsError):\n assert self.func(a, b, rtol, atol)","def test_convert_compatible_units(self):\n result = convert_units(self.arr, 'degC')\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\n expected_units = cf_units.Unit('degC')\n self.assertEquals(result.units, expected_units)\n self.assertArrayEqual(result.data, expected_data)","def test_hr2sec(self):\n result = TimeUnit(-1.7, 'hr', 'sec')\n self.assertRaises(ValueError, lambda: result.doconvert())","def _convert_unit(self, unit):\n if unit in self.units:\n return self.units[unit]\n elif unit in unit_map:\n return unit_map[unit]\n else:\n raise SBMLError('Unit not recognized: ' + str(unit))","def test_non_cast_input():\n assert _currency_column_to_numeric(\"-1,000,000 yen\") == \"-1000000\"","def test_convert_to_SI_units_when_no_units():\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_arr.xml\"\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_mod_arr.xml\"\n parser = XMLParser(xml_filename, convert_to_SI_units=True)","def convert_units(cube, units):\n try:\n cube.convert_units(units)\n except ValueError:\n if not _try_special_conversions(cube, units):\n raise\n\n return cube","def parse_unit(unit_string):\n with warnings.catch_warnings():\n warnings.filterwarnings('ignore', module='astropy')\n try:\n unit = u.Unit(unit_string, parse_strict='raise')\n except ValueError:\n new_string = unit_string.replace('(cm-1)', 'kayser')\n log.debug(f'\\tValue Error, try {new_string}')\n unit = u.Unit(new_string,\n parse_strict='silent')\n log.debug(f'Parsed {unit_string} into {unit} ({type(unit)}).')\n return unit","def test_unit_conversion_fail_arr_onlyE_units():\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_arr_onlyEunits.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)","def convert_to(self, units: str) -> None:\n if self.units == units:\n return\n\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\n msg = f\"\"\"Not a valid unit conversion. Valid destination units:\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\"\"\"\n raise ValueError(msg)\n\n if self.units == \"celsius\" and units == \"fahrenheit\":\n self._celsius_to_fahrenheit()\n elif self.units == \"m/s\" and units == \"km/h\":\n self._mps_to_kph()\n elif self.units == \"m/s\" and units == \"mph\":\n self._mps_to_mph()\n else:\n raise ValueError(\"Not a valid unit conversion.\")","def test_not_int(self):\n invalid_args = [\"random string\", \"123\", 123.5]\n for arg in invalid_args:\n assert meters_to_km(arg) is arg","def unit_conversion(thing, units, length=False):\n if 'n/a' == thing:\n return 'n/a'\n try:\n thing = round(thing * CONVERSION[units][0 + length], 2)\n except:\n thing = 'fubar'\n return thing, CONVERSION[units][2 + length]","def unit2internal(src_unit: Union[str, float]):\n return _parse_unit(src_unit, conversion_factor=_conversion_factor_internal)","def test_from_knx_wrong_parameter(self):\n with self.assertRaises(ConversionError):\n DPTValue1Ucount().from_knx((0x01, 0x02, 0x03))","def test_cast_fail(self, option, value):\n with pytest.raises(errors.BisonError):\n option.cast(value)","def convert(x, unit1, unit2):\r\n return conversions[unit1][unit2](x)","def test_not_units(self):\n with self.assertRaises(AssertionError):\n _unit_map(\"WiB\")","def unit_converter(val, from_u, to_u):\n\tconverter = {'b':0, 'k':1, 'm':2, 'g':3, 't':4}\n\tif converter[from_u] < converter[to_u]:\n\t\tval = float(val)\n\t\tfor _ in range(converter[to_u] - converter[from_u]):\n\t\t\tval = val/1024\n\telse:\n\t\tfor _ in range(converter[from_u] - converter[to_u]):\n\t\t\tval = val * 1024\n\t\t\t\n\treturn val","def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\n return process_unit_input(value, units, convert=True, registry=registry).v","def test_unsupported_units(self):\n with pytest.raises(TypeError):\n set_default_units(\"bad\")\n with pytest.raises(TypeError):\n State(\"water\", T=Q_(100, \"degC\"), p=Q_(1.0, \"atm\"), units=\"bad\")","def to_unit(self, unit):\n unit = _find_unit(unit)\n self.value = _convert_value(self.value, self.unit, unit)\n self.unit = unit","def getunittouu(self, param):\n if type(param) is tuple:\n return tuple([self.getunittouu(val) for val in param])\n try:\n return inkex.unittouu(param)\n except AttributeError:\n return self.unittouu(param)","def test_invalid_units(self):\n with self.assertRaises(ValueError):\n UnitSystem(SYSTEM_NAME, INVALID_UNIT, LENGTH_METERS, VOLUME_LITERS,\n MASS_GRAMS)\n\n with self.assertRaises(ValueError):\n UnitSystem(SYSTEM_NAME, TEMP_CELSIUS, INVALID_UNIT, VOLUME_LITERS,\n MASS_GRAMS)\n\n with self.assertRaises(ValueError):\n UnitSystem(SYSTEM_NAME, TEMP_CELSIUS, LENGTH_METERS, INVALID_UNIT,\n MASS_GRAMS)\n\n with self.assertRaises(ValueError):\n UnitSystem(SYSTEM_NAME, TEMP_CELSIUS, LENGTH_METERS, VOLUME_LITERS,\n INVALID_UNIT)","def test_to_unicode_raises_on_non_string():\n with pytest.raises(TypeError):\n to_unicode(999)","def convertToSI(*args):\n return _libsbml.Unit_convertToSI(*args)","def test_unit_conversion(self):\n self.cube_uv_down.convert_units(\"kW m-2\")\n scale_factor = 1.0\n expected = np.full_like(\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\n )\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\n self.assertArrayEqual(result.data, expected)","def unit(variable, unit):\n try:\n return myokit.Unit.convert(1, variable.unit(), unit)\n except myokit.IncompatibleUnitError:\n raise myokit.IncompatibleModelError(\n variable.model().name(),\n 'Incompatible units: ' + str(variable.unit()) + ' and '\n + str(unit) + '.')","def test_to_knx_wrong_parameter(self):\n with self.assertRaises(ConversionError):\n DPTValue1Ucount().to_knx(\"fnord\")","def test_from_knx_wrong_value(self):\n with self.assertRaises(ConversionError):\n DPTValue1Ucount().from_knx((0x256,))","def convert_units(self, time_units=None, len_units=None, pump_units=None,\n same=False):\n in_time = self.time_units\n # Check new time units\n if time_units is None:\n time_units = in_time\n flag = _units.validate_units(time_units)\n if flag == -1:\n raise ValueError('Bad time units input {}'.format(time_units))\n # Check new length units\n in_len = self.len_units\n if len_units is None:\n len_units = in_len\n flag = _units.validate_units(len_units)\n if flag == -1:\n raise ValueError('Bad length units input {}'.format(len_units))\n # Check new pumping rate units\n in_pump = self.pump_units\n if pump_units is None:\n pump_units = in_pump\n if same:\n pump_units = \"%s3/%s\" % (len_units, time_units)\n flag = _units.validate_units(pump_units)\n if flag == -1:\n raise ValueError('Bad pumping rate units input {}'.format(len_units))\n\n # Convert parameters units\n for key, value in self.parameters.items():\n if type(value) in [int, float]:\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\n # Convert pumping rate data\n self.pumprate.convert_units(time_units, pump_units)\n # Convert well data units\n for i in range(self.well_count()):\n self.wells[i].convert_units(time_units, len_units)\n # Set input units\n self.len_units = len_units\n self.time_units = time_units\n self.pump_units = pump_units\n # End Function","def test_wrong_argument_for_encoding(self):\n with self.assertRaises(exceptions.WrongArgumentTypeError):\n positional.encode(4.5, 10)","def test_length_unknown_unit(self):\n with self.assertRaises(ValueError):\n METRIC_SYSTEM.length(5, 'fr')","def test_unit(self):\n self.assertEqual(DPTSignedRelativeValue.unit, \"\")\n self.assertEqual(DPTPercentV8.unit, \"%\")\n self.assertEqual(DPTValue1Count.unit, \"counter pulses\")","def useUnits():","def test_day_microseconds_wrong_type(self):\n with self.assertRaises(ValueError):\n utils.day_microseconds('dummy')","def convert_from_to(from_unit, to_unit, quantity):\n if not is_valid_unit(from_unit):\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\n if not is_valid_unit(to_unit):\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]","def test_invalid_value(self):\n with self.assertRaises(TypeError):\n METRIC_SYSTEM.length('25a', LENGTH_KILOMETERS)\n with self.assertRaises(TypeError):\n METRIC_SYSTEM.temperature('50K', TEMP_CELSIUS)","def test_convert_amounts(self):\n pass","def convert_units(unt, origunits):\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\n units = origunits\n convf = 1\n else:\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'met':\n units = 'feet'\n convf = 3.2808399\n else:\n units = origunits\n convf = 1\n else:\n if 'met' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'fee':\n units = 'meters'\n convf = 0.3048\n else:\n units = origunits\n convf = 1\n else:\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'kno':\n units = 'meters/sec'\n convf = 0.51444444\n else:\n units = origunits\n convf = 1\n else:\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'm/s':\n units = 'knots'\n convf = 1.9438445\n else:\n units = origunits\n convf = 1\n else:\n error('Unknown units')\n #\n return units, convf","def to_unit_validator(compatible_units):\n def _to_unit_validator(quantity_str):\n return process_unit_bearing_str(quantity_str, compatible_units)\n return _to_unit_validator","def process_unit_input(in_,\n default_units: UnitLike = None,\n convert: bool = False,\n check_dims: bool = False,\n copy: bool = True,\n registry: unyt.UnitRegistry = None) -> unyt_array:\n parser = UnitInputParser(default_units=default_units,\n convert=convert,\n check_dims=check_dims,\n copy=copy,\n registry=registry)\n return parser.parse(in_)","def test_convert():","def convert_physical_value(value: str, unit: str = None, strip_units=True):\n\n # Ensure that the value is a string\n value = str(value).strip()\n\n # Error on blank values\n if not value:\n raise ValidationError(_('No value provided'))\n\n ureg = get_unit_registry()\n error = ''\n\n try:\n # Convert to a quantity\n val = ureg.Quantity(value)\n\n if unit:\n\n if is_dimensionless(val):\n # If the provided value is dimensionless, assume that the unit is correct\n val = ureg.Quantity(value, unit)\n else:\n # Convert to the provided unit (may raise an exception)\n val = val.to(unit)\n\n # At this point we *should* have a valid pint value\n # To double check, look at the maginitude\n float(ureg.Quantity(val.magnitude).magnitude)\n except (TypeError, ValueError, AttributeError):\n error = _('Provided value is not a valid number')\n except (pint.errors.UndefinedUnitError, pint.errors.DefinitionSyntaxError):\n error = _('Provided value has an invalid unit')\n if unit:\n error += f' ({unit})'\n\n except pint.errors.DimensionalityError:\n error = _('Provided value could not be converted to the specified unit')\n if unit:\n error += f' ({unit})'\n\n except Exception as e:\n error = _('Error') + ': ' + str(e)\n\n if error:\n raise ValidationError(error)\n\n # Calculate the \"magnitude\" of the value, as a float\n # If the value is specified strangely (e.g. as a fraction or a dozen), this can cause isuses\n # So, we ensure that it is converted to a floating point value\n # If we wish to return a \"raw\" value, some trickery is required\n if unit:\n magnitude = ureg.Quantity(val.to(unit)).magnitude\n else:\n magnitude = ureg.Quantity(val.to_base_units()).magnitude\n\n magnitude = float(ureg.Quantity(magnitude).to_base_units().magnitude)\n\n if strip_units:\n return magnitude\n elif unit or val.units:\n return ureg.Quantity(magnitude, unit or val.units)\n else:\n return ureg.Quantity(magnitude)","def test_to_int(self):\n self.assertEqual(to_int(u\"3\"), 3)\n self.assertEqual(to_int(u\"asdf\"), 0)\n self.assertEqual(to_int(None), 0)","def test_temperature_unknown_unit(self):\n with self.assertRaises(ValueError):\n METRIC_SYSTEM.temperature(5, 'K')","def test_inches_invalid_input(self):\n result = inch_to_cm(\"--\")\n self.assertIsNone(result)","def spice_unit_convert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result /= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result *= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\n result *= numeric(spice_unit_unconvert([part, \"1.0\"], restrict))\n return str(result)\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n else:\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n newvalue = numeric(valuet[1]) * 0.01\n return str(newvalue)\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def conversionNotPossibleException(valueType: cern.japc.value.ValueType, valueType2: cern.japc.value.ValueType) -> cern.japc.value.ValueConversionException:\n ...","def convert_string_to_unit(s):\n \n if \":\" not in s:\n match = UNIT_RE.match(s)\n if match:\n s = \"%s:%s\"%match.groups()\n \n return Unit(s)","def convert_same_units(self):\n # Convert pumping rate data\n pump_units = \"%s3/%s\" % (self.len_units, self.time_units)\n flag = _units.validate_units(pump_units)\n if flag == 2:\n self.pumprate.convert_units(self.time_units, pump_units)\n self.pump_units = pump_units","def test_convert_likelihood_invalid_input():\n with pytest.raises(ValueError) as err:\n convert_likelihood(to='aaa', ts=30, df=4)\n assert \"Invalid parameter `to`: aaa\" in str(err)\n\n with pytest.raises(ValueError) as err:\n convert_likelihood(to='ts')\n assert \"You have to pass exactly one\" in str(err)\n\n with pytest.raises(ValueError) as err:\n convert_likelihood(to='ts', ts=99, chi2=99)\n assert \"You have to pass exactly one\" in str(err)\n\n with pytest.raises(ValueError) as err:\n convert_likelihood(to='significance', ts=99)\n assert 'You have to specify the number of degrees of freedom via the `df` parameter.' in str(err)","def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)","def test_dummy(self, data):\r\n source, expected = data\r\n result = self.converter.convert(source)\r\n self.assertUnicodeEquals(result, expected)","def convert_units(self, time_units=None, len_units=None):\n in_time = self.time_units\n # Check new time units\n if time_units is None:\n time_units = in_time\n flag = _units.validate_units(time_units)\n if flag == -1:\n raise ValueError('Bad time units input {}'.format(time_units))\n # Check new length units\n in_len = self.len_units\n if len_units is None:\n len_units = in_len\n flag = _units.validate_units(len_units)\n if flag == -1:\n raise ValueError('Bad length units input {}'.format(len_units))\n # Convert parameters units\n for key, value in self.parameters.items():\n if type(value) in [int, float]:\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\n # Convert drawdown data\n self.drawdown.convert_units(time_units, len_units)\n # Convert associate data units\n for i in range(self.data_count()):\n if self.data[i].dtype == 1: # drawdown units\n data_units = len_units\n elif self.data[i].dtype == 2: # first derivative units\n data_units = len_units + \"/\" + time_units\n elif self.data[i].dtype == 3: # second derivative units\n data_units = len_units + \"/\" + time_units + \"2\"\n self.data[i].convert_units(time_units, data_units)\n self.len_units = len_units\n self.time_units = time_units\n # End Function","def test_unit_conversion_compatible(self):\n self.orography_cube.convert_units('ft')\n probability_cube = self.plugin_instance.process(self.orography_cube)\n self.assertIsInstance(probability_cube, iris.cube.Cube)\n self.assertSequenceEqual(probability_cube.shape,\n self.reference_cube.shape)","def test_check_wrong_argument_type(self, number, base):\n with self.assertRaises(exceptions.WrongArgumentTypeError):\n positional.decode(number, base)","def test_bad_values(self):\n self.assertOK([60])\n self.assertRaisesInternalError([59.9])\n self.assertRaisesInternalError([''])\n self.assertRaisesInternalError([';'])\n self.assertRaisesInternalError(['('])\n self.assertRaisesInternalError([None])","def doconvert(self, error_on_negative=True):\n if error_on_negative and self.amt < 0:\n raise ValueError('Amount must be a positive number')\n conv = (self.amt * self._getuval(self.ufrom)) / self._getuval(self.uto)\n return conv","def _to(\n value: Union[\"Value\", \"ValueArray\"], units: Union[Unit, str], inplace: bool\n) -> Any:\n if value.units == units:\n return value\n\n if value.units is None:\n raise RuntimeError(\"Cannot convert with units=None\")\n\n try:\n units = next(\n imp_unit\n for imp_unit in value.implemented_units\n if units.lower() in imp_unit.aliases\n )\n\n except StopIteration:\n raise TypeError(\n f\"No viable unit conversion from {value.units} -> {units}\"\n )\n\n if not (isinstance(value, Value) or isinstance(value, ValueArray)):\n raise ValueError(\n f\"Cannot convert {value} to new units. Must be one of\"\n f\" Value of ValueArray\"\n )\n\n if isinstance(value, Value) and inplace:\n raise ValueError(\n \"Cannot modify a value inplace as floats are immutable\"\n )\n\n # Convert to the base unit, then to the new units\n c = float(units.conversion / value.units.conversion)\n\n new_value = value if inplace else value.copy()\n new_value *= c\n new_value.units = units\n\n return None if inplace else new_value","def test_conversion_type(self):\r\n self.assertRaises(ValueError, convert_fastaqual_fastq,\r\n self.fasta_file_path, self.qual_file_path, conversion_type='soijdfl',\r\n output_directory=self.output_dir)","def try_consume_units(self, units):\n pass","def test_convert_with_blank_input():\n assert convert(\"\") == \"\"","def test_convertCharToInt_bad_value(self):\n self.assertRaises(ValueError, rules.convertCharToInt, 'qq')","def convert_units(self, units):\n self.unit_array = self.unit_array.to(units)","def test_creation_float():\n with pytest.raises(ValueError) as __:\n value = 42.30474\n __ = param.Integer(value=value)","def test_human_size_units_to_base(self):\n self.assertEqual(human_size_units_to_base(1), 1)\n self.assertEqual(human_size_units_to_base('1'), 1)\n self.assertEqual(human_size_units_to_base('1b'), 1)\n self.assertEqual(human_size_units_to_base('1k'), 1000)\n self.assertEqual(human_size_units_to_base('1kb'), 1000)\n self.assertEqual(human_size_units_to_base('1kib'), 1024)\n self.assertEqual(human_size_units_to_base('1KiB'), 1024)\n self.assertEqual(human_size_units_to_base('1KiB 1b'), 1025)\n self.assertEqual(human_size_units_to_base('1M'), 1000000)\n self.assertEqual(human_size_units_to_base('1Mi'), 1024*1024)\n self.assertEqual(human_size_units_to_base('1G'), 1000000000)\n self.assertEqual(human_size_units_to_base('1T'), 1000000000000)\n self.assertRaisesRegex(ValueError, 'Bad unit \"a\" in size parameter \"1a\".', human_size_units_to_base, '1a')","def test_invalid_component_values():\n\n # Test Arrhenius-type reaction when nonsensical R value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_arr_invalidR.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=False)\n\n # Test Arrhenius-type reaction when nonsensical A value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_arr_A.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n # Test Arrhenius-type reaction when nonsensical E value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_arr_E.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n # Test modified Arrhenius-type reaction when nonsensical R value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_modarr_invalidR.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=False)\n\n # Test modified Arrhenius-type reaction when nonsensical A value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_modarr_A.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n # Test modified Arrhenius-type reaction when nonsensical b value (e.g. string) \n xml_filename = \"tests/test_xml_files/unit_conversion_fail_modarr_b.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\n\n # Test modified Arrhenius-type reaction when nonsensical E value (e.g. string)\n xml_filename = \"tests/test_xml_files/unit_conversion_fail_modarr_E.xml\"\n with pytest.raises(ValueError):\n parser = XMLParser(xml_filename, convert_to_SI_units=True)","def test_invalid_argument_type(self):\n t = TruthTable('A or B')\n\n with self.assertRaises(InvalidArgumentTypeError):\n t.equivalent_to(float())\n\n with self.assertRaises(InvalidArgumentTypeError):\n t.equivalent_to(None)","def cast_value(value, unit):\n if isinstance(value, u.Quantity):\n return value.to(unit)\n return value * unit","def test_buoy_format2():\n with pytest.raises(AssertionError) as err_info:\n Check_BuoyDC.check_buoy_format(buoy_format_fail_2)\n assert str(err_info.value) == 'Input length incorrect, see instructions'","def test_process_args_should_reject_fractional_resolution_values(self, arg_dict):\n self.use_resolution_val(arg_dict, 600.1)\n with pytest.raises(TypeError):\n change_resolution.process_args(arg_dict)","def test_cast_string_failure(self) -> None:\n self.flag.flag_type = None\n self.assertRaises(ValueError, self.flag.cast_string, '42')","def check_units(self, secondary_spectrum):\n\n if self.unit != secondary_spectrum.unit:\n raise ValueError('Spectra are in different units!')","def test_jy_to_mk_freq_wrong_units():\n test_fq = np.array([0.1]) * units.m\n pytest.raises(units.UnitsError, utils.jy_to_mk, test_fq)","def test_different_units(self):\n self.temperature.convert_units(\"celsius\")\n self.relative_humidity.convert_units(\"1\")\n self.pressure.convert_units(\"kPa\")\n result = WetBulbTemperature().create_wet_bulb_temperature_cube(\n self.temperature, self.relative_humidity, self.pressure\n )\n self.assertArrayAlmostEqual(result.data, self.expected_wbt_data, decimal=3)\n self.assertEqual(result.units, Unit(\"K\"))","def test_cast_non_numeric_false():\n assert _currency_column_to_numeric(\"10 dollars\", {\"foo\": 42}) == \"10\"","def SBMLUnitsConverter_init():\n return _libsbml.SBMLUnitsConverter_init()","def unit_arg(option, opt, value, parser):\n actual = from_units(value)\n if actual is None:\n parser.error('Invalid value \\'%s\\' for %s' % (value, opt))\n setattr(parser.values, option.dest, actual)","def test_float():\n assert float(Quantity(1, unit('m'))) == float(1)","def convert_units(data, units):\n # Build the dictionary of units conversions\n convert = {'m' : [1.0, 0., 'm'], \n 'meter' : [1.0, 0., 'm'], \n 'deg C' : [1.0, 273.15, 'K'], \n 'Celsius' : [1.0, 273.15, 'K'], \n 'K' : [1.0, 0., 'K'],\n 'db' : [1.e4, 101325., 'Pa'], \n 'Pa' : [1.0, 0., 'Pa'],\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \n 'S/m': [1.0, 0., 'S/m'],\n 'mS/m' : [1.e-3, 0., 'S/m'],\n 'psu': [1.0, 0., 'psu'], \n 'salinity': [1.0, 0., 'psu'], \n 'kg/m^3': [1.0, 0., 'kg/m^3'], \n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \n 'm/s': [1.0, 0., 'm/s'], \n 'mg/l': [1.e-3, 0., 'kg/m^3'],\n 'meter second-1' : [1.0, 0., 'm/s'],\n 'm.s-1' : [1.0, 0., 'm/s'],\n 'pH units' : [1.0, 0., 'pH units'],\n 'MPa' : [1.e6, 0., 'Pa'],\n '--' : [1.0, 0., '--'],\n 'mD' : [9.869233e-16, 0., 'm^2'],\n 'um' : [1.e-6, 0., 'm'],\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\n 'wt.%' : [10., 0., 'psu'],\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\n 'm^2' : [1., 0., 'm^2'],\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \n } \n \n # Make sure the data are a numpy array and the units are a list\n if isinstance(data, float) or isinstance(data, int):\n data = np.array([data])\n if isinstance(data, list):\n data = np.array(data)\n if isinstance(units, str) or isinstance(units, unicode):\n units = [units]\n if units == None:\n units = ['']\n \n # Make sure you can slice through the columns: must be two-dimensional\n sh = data.shape\n data = np.atleast_2d(data)\n \n # Allow conversion of a row of data if all of the same unit\n if len(units) == 1 and data.shape[1] > 1:\n data = data.transpose()\n \n # Create an emtpy array to hold the output\n out_data = np.zeros(data.shape)\n out_units = []\n \n # Convert the units\n for i in range(len(units)):\n try:\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\n convert[units[i]][1]\n out_units += [convert[units[i]][2]]\n except KeyError:\n print('Do not know how to convert %s to mks units' % units[i])\n print('Continuing without converting these units...')\n out_data[:,i] = data[:,i]\n out_units += units[i]\n \n # Return the converted data in the original shape\n out_data = np.reshape(out_data, sh, 'C')\n return (out_data, out_units)","def spice_unit_unconvert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item / spice_unit_unconvert([parts[1], 1.0],\n\t\t\trestrict) for item in result)\n else:\n result /= spice_unit_unconvert([parts[1], 1.0], restrict)\n return result\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item * spice_unit_unconvert([parts[1], 1.0],\n\t\t\trestrict) for item in result)\n else:\n result *= spice_unit_unconvert([parts[1], 1.0], restrict)\n return result\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = spice_unit_unconvert([part, valuet[1]], restrict)\n if isinstance(result, list):\n result = list(item * spice_unit_unconvert([part, 1.0],\n\t\t\trestrict) for item in result)\n else:\n result *= spice_unit_unconvert([part, 1.0], restrict)\n return result\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n if isinstance(valuet[1], list):\n return list(item / prefixtypes[prerec] for item in valuet[1])\n else:\n return valuet[1] / prefixtypes[prerec]\n else:\n if isinstance(valuet[1], list):\n return list(item / prefixtypes[prerec] for item in valuet[1])\n else:\n return valuet[1] / prefixtypes[prerec]\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n if isinstance(valuet[1], list):\n return list(item * 100 for item in valuet[1])\n else:\n return valuet[1] * 100\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def unit(cls, val):\n raise NotImplementedError","def test_type_errors():\n\n\ttry:\n\t\ttransmissions = compute_transmissions(cal_directory, lines = 3.0)\n\texcept TypeError:\n\t\ttry:\n\t\t\ttransmissions = compute_transmissions(cal_directory, calibrator = 300.0)\n\t\texcept TypeError:\n\t\t\tassert True\n\t\telse:\n\t\t\tassert False\n\telse:\n\t\tassert False"],"string":"[\n \"def convertUnit(*args, fromUnit: AnyStr=\\\"\\\", toUnit: AnyStr=\\\"\\\", **kwargs)->float:\\n pass\",\n \"def test_convert_invalid_unit():\\n with pytest.raises(ValueError):\\n pressure_util.convert(5, INVALID_SYMBOL, VALID_SYMBOL)\\n\\n with pytest.raises(ValueError):\\n pressure_util.convert(5, VALID_SYMBOL, INVALID_SYMBOL)\",\n \"def test_convert_incompatible_units(self):\\n self.assertRaises(ValueError, convert_units, self.arr, 'm')\",\n \"def test_convert_same_unit():\\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5\",\n \"def test_unit_conversion_incompatible(self):\\n self.orography_cube.units = 'K'\\n msg = \\\"Unable to convert from\\\"\\n with self.assertRaisesRegex(ValueError, msg):\\n self.plugin_instance.process(self.orography_cube)\",\n \"def test_convert_nonnumeric_value():\\n with pytest.raises(TypeError):\\n pressure_util.convert(\\\"a\\\", PRESSURE_HPA, PRESSURE_INHG)\",\n \"def try_convert(self, func, *args, **kwargs):\\n try:\\n func(*args, **kwargs)\\n except UnitsError, e:\\n if self.show_xml_context_only:\\n e.show_xml_context_only()\\n if self.warn_only:\\n e.warn = True\\n e.level = logging.WARNING\\n logging.getLogger('units-converter').log(e.level, unicode(e).encode('UTF-8'))\",\n \"def test_ms2min(self):\\n result = TimeUnit(-50, 'ms', 'min')\\n self.assertRaises(ValueError, lambda: result.doconvert())\",\n \"def _convert_to_and_validate_distance_unit(unit):\\n if unit is not None:\\n unit = u.Unit(unit)\\n\\n if not unit.is_equivalent(u.kpc):\\n raise u.UnitsError(six.u('Unit \\\"{0}\\\" is not a distance').format(unit))\\n return unit\",\n \"def convert_units(value, from_unit, to_unit, **args):\\n\\n # Check if units can be converted\\n if not can_convert(from_unit, to_unit):\\n return '[!] Units cannot be converted\\\\n'\\n\\n # Extract the numeric value from the string\\n decimal_places = 2 # Set the default value of precision\\n if \\\".\\\" in str(value):\\n decimal_places = len(str(value)[str(value).index('.') + 1:])\\n\\n # Return the value if units are the same\\n if from_unit == to_unit:\\n return str(value) + \\\" \\\" + get_si(to_unit)\\n\\n responses = [\\n check_time(value, from_unit, to_unit, decimal_places), # Time units\\n check_metric_imperial(\\n value,\\n from_unit,\\n to_unit,\\n decimal_places), # Metric and Imperial units\\n check_digital_storage(\\n value,\\n from_unit,\\n to_unit,\\n decimal_places\\n ) # Digital storage units\\n ]\\n\\n for response in responses:\\n if response:\\n return response\\n\\n # actually convert the units\\n try:\\n return str(round(convert(from_unit, to_unit, float(value), **args), decimal_places)) + \\\" \\\" + get_si(to_unit)\\n except RequireAdditionalParamError as e:\\n additional_unit = input(\\\"\\\\n[*] Enter an additional unit (choose between \\\" + str(e.additional_params) + \\\"): \\\")\\n additional_value = float(input(\\\"\\\\n[*] Enter the value: \\\"))\\n return convert_units(value, from_unit, to_unit, **{additional_unit: additional_value})\\n except ConversionError as e:\\n print(e.reason)\",\n \"def test_as_type_invalid_cast(self, wrapped_unit: MyType) -> None:\\n # Arrange.\\n # Create a new fake UnitType.\\n other_type = mock.MagicMock()\\n # Give it a name for easier debugging.\\n other_type.__name__ = \\\"OtherType\\\"\\n\\n # A fake unit to convert.\\n to_convert = MyUnit(wrapped_unit, 10)\\n\\n # Act and assert.\\n # Conversion should fail since no cast is registered.\\n with pytest.raises(CastError):\\n wrapped_unit.as_type(to_convert, other_type)\",\n \"def test_wrongunit(self, a, b, rtol, atol):\\n with pytest.raises(u.UnitsError):\\n self.func(a, b, rtol, atol)\",\n \"def Unit_convertToSI(*args):\\n return _libsbml.Unit_convertToSI(*args)\",\n \"def ensure_unit(arg, unit):\\n if not isinstance(arg, u.Quantity):\\n arg = arg * unit\\n return arg.to(unit)\",\n \"def describe_a_library_of_units_converters_that():\\n def blows_smoke():\\n assert True\\n\\n def can_convert_psi_to_kpa():\\n assert psi2kpa(32) == 220.631712 # 32 PSI == 220.631712 KPa; average car tire pressure\\n assert psi2kpa(8.5) == 58.6052985 # 8.5 PSI == 58.6052985 KPa; basketball pressure\\n\\n # def can_convert_kpa_to_psi():\\n # assert kpa2psi(101.325) == 14.695952495133 # KPa => PSI; average air pressure at sea level\\n # assert kpa2psi(220.631712) == 31.999932479367043 # KPa => PSI; average car tire pressure\\n\\n # def can_convert_mpg_to_lp100k():\\n # assert mpg2lp100k(40) == 5.8803694563 # miles-per-gallon => liters per 100km\\n # assert mpg2lp100k(25) == 9.408591130080001 # miles-per-gallon => liters per 100km\\n\\n # def can_convert_lp100k_to_mpg():\\n # assert lp100k2mpg(9.4) == 25.022895167663442 # liters per 100km => mpg\\n # assert lp100k2mpg(5.1) == 46.12063030902673 # liters per 100km => mpg\",\n \"def test_wk2yr(self):\\n result = TimeUnit(-34, 'wk', 'yr')\\n self.assertRaises(ValueError, lambda: result.doconvert())\",\n \"def test_from_knx_wrong_parameter2(self):\\n with self.assertRaises(ConversionError):\\n DPTValue1Ucount().from_knx(\\\"0x23\\\")\",\n \"def test_wrongunit(self, a, b, rtol, atol, expected):\\n with pytest.raises(u.UnitsError):\\n assert self.func(a, b, rtol, atol)\",\n \"def test_convert_compatible_units(self):\\n result = convert_units(self.arr, 'degC')\\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\\n expected_units = cf_units.Unit('degC')\\n self.assertEquals(result.units, expected_units)\\n self.assertArrayEqual(result.data, expected_data)\",\n \"def test_hr2sec(self):\\n result = TimeUnit(-1.7, 'hr', 'sec')\\n self.assertRaises(ValueError, lambda: result.doconvert())\",\n \"def _convert_unit(self, unit):\\n if unit in self.units:\\n return self.units[unit]\\n elif unit in unit_map:\\n return unit_map[unit]\\n else:\\n raise SBMLError('Unit not recognized: ' + str(unit))\",\n \"def test_non_cast_input():\\n assert _currency_column_to_numeric(\\\"-1,000,000 yen\\\") == \\\"-1000000\\\"\",\n \"def test_convert_to_SI_units_when_no_units():\\n with pytest.raises(ValueError):\\n xml_filename = \\\"tests/test_xml_files/A_arr.xml\\\"\\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\\n\\n with pytest.raises(ValueError):\\n xml_filename = \\\"tests/test_xml_files/A_mod_arr.xml\\\"\\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\",\n \"def convert_units(cube, units):\\n try:\\n cube.convert_units(units)\\n except ValueError:\\n if not _try_special_conversions(cube, units):\\n raise\\n\\n return cube\",\n \"def parse_unit(unit_string):\\n with warnings.catch_warnings():\\n warnings.filterwarnings('ignore', module='astropy')\\n try:\\n unit = u.Unit(unit_string, parse_strict='raise')\\n except ValueError:\\n new_string = unit_string.replace('(cm-1)', 'kayser')\\n log.debug(f'\\\\tValue Error, try {new_string}')\\n unit = u.Unit(new_string,\\n parse_strict='silent')\\n log.debug(f'Parsed {unit_string} into {unit} ({type(unit)}).')\\n return unit\",\n \"def test_unit_conversion_fail_arr_onlyE_units():\\n xml_filename = \\\"tests/test_xml_files/unit_conversion_fail_arr_onlyEunits.xml\\\"\\n with pytest.raises(ValueError):\\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\",\n \"def convert_to(self, units: str) -> None:\\n if self.units == units:\\n return\\n\\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\\n msg = f\\\"\\\"\\\"Not a valid unit conversion. Valid destination units:\\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\\\"\\\"\\\"\\n raise ValueError(msg)\\n\\n if self.units == \\\"celsius\\\" and units == \\\"fahrenheit\\\":\\n self._celsius_to_fahrenheit()\\n elif self.units == \\\"m/s\\\" and units == \\\"km/h\\\":\\n self._mps_to_kph()\\n elif self.units == \\\"m/s\\\" and units == \\\"mph\\\":\\n self._mps_to_mph()\\n else:\\n raise ValueError(\\\"Not a valid unit conversion.\\\")\",\n \"def test_not_int(self):\\n invalid_args = [\\\"random string\\\", \\\"123\\\", 123.5]\\n for arg in invalid_args:\\n assert meters_to_km(arg) is arg\",\n \"def unit_conversion(thing, units, length=False):\\n if 'n/a' == thing:\\n return 'n/a'\\n try:\\n thing = round(thing * CONVERSION[units][0 + length], 2)\\n except:\\n thing = 'fubar'\\n return thing, CONVERSION[units][2 + length]\",\n \"def unit2internal(src_unit: Union[str, float]):\\n return _parse_unit(src_unit, conversion_factor=_conversion_factor_internal)\",\n \"def test_from_knx_wrong_parameter(self):\\n with self.assertRaises(ConversionError):\\n DPTValue1Ucount().from_knx((0x01, 0x02, 0x03))\",\n \"def test_cast_fail(self, option, value):\\n with pytest.raises(errors.BisonError):\\n option.cast(value)\",\n \"def convert(x, unit1, unit2):\\r\\n return conversions[unit1][unit2](x)\",\n \"def test_not_units(self):\\n with self.assertRaises(AssertionError):\\n _unit_map(\\\"WiB\\\")\",\n \"def unit_converter(val, from_u, to_u):\\n\\tconverter = {'b':0, 'k':1, 'm':2, 'g':3, 't':4}\\n\\tif converter[from_u] < converter[to_u]:\\n\\t\\tval = float(val)\\n\\t\\tfor _ in range(converter[to_u] - converter[from_u]):\\n\\t\\t\\tval = val/1024\\n\\telse:\\n\\t\\tfor _ in range(converter[from_u] - converter[to_u]):\\n\\t\\t\\tval = val * 1024\\n\\t\\t\\t\\n\\treturn val\",\n \"def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\\n return process_unit_input(value, units, convert=True, registry=registry).v\",\n \"def test_unsupported_units(self):\\n with pytest.raises(TypeError):\\n set_default_units(\\\"bad\\\")\\n with pytest.raises(TypeError):\\n State(\\\"water\\\", T=Q_(100, \\\"degC\\\"), p=Q_(1.0, \\\"atm\\\"), units=\\\"bad\\\")\",\n \"def to_unit(self, unit):\\n unit = _find_unit(unit)\\n self.value = _convert_value(self.value, self.unit, unit)\\n self.unit = unit\",\n \"def getunittouu(self, param):\\n if type(param) is tuple:\\n return tuple([self.getunittouu(val) for val in param])\\n try:\\n return inkex.unittouu(param)\\n except AttributeError:\\n return self.unittouu(param)\",\n \"def test_invalid_units(self):\\n with self.assertRaises(ValueError):\\n UnitSystem(SYSTEM_NAME, INVALID_UNIT, LENGTH_METERS, VOLUME_LITERS,\\n MASS_GRAMS)\\n\\n with self.assertRaises(ValueError):\\n UnitSystem(SYSTEM_NAME, TEMP_CELSIUS, INVALID_UNIT, VOLUME_LITERS,\\n MASS_GRAMS)\\n\\n with self.assertRaises(ValueError):\\n UnitSystem(SYSTEM_NAME, TEMP_CELSIUS, LENGTH_METERS, INVALID_UNIT,\\n MASS_GRAMS)\\n\\n with self.assertRaises(ValueError):\\n UnitSystem(SYSTEM_NAME, TEMP_CELSIUS, LENGTH_METERS, VOLUME_LITERS,\\n INVALID_UNIT)\",\n \"def test_to_unicode_raises_on_non_string():\\n with pytest.raises(TypeError):\\n to_unicode(999)\",\n \"def convertToSI(*args):\\n return _libsbml.Unit_convertToSI(*args)\",\n \"def test_unit_conversion(self):\\n self.cube_uv_down.convert_units(\\\"kW m-2\\\")\\n scale_factor = 1.0\\n expected = np.full_like(\\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\\n )\\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\\n self.assertArrayEqual(result.data, expected)\",\n \"def unit(variable, unit):\\n try:\\n return myokit.Unit.convert(1, variable.unit(), unit)\\n except myokit.IncompatibleUnitError:\\n raise myokit.IncompatibleModelError(\\n variable.model().name(),\\n 'Incompatible units: ' + str(variable.unit()) + ' and '\\n + str(unit) + '.')\",\n \"def test_to_knx_wrong_parameter(self):\\n with self.assertRaises(ConversionError):\\n DPTValue1Ucount().to_knx(\\\"fnord\\\")\",\n \"def test_from_knx_wrong_value(self):\\n with self.assertRaises(ConversionError):\\n DPTValue1Ucount().from_knx((0x256,))\",\n \"def convert_units(self, time_units=None, len_units=None, pump_units=None,\\n same=False):\\n in_time = self.time_units\\n # Check new time units\\n if time_units is None:\\n time_units = in_time\\n flag = _units.validate_units(time_units)\\n if flag == -1:\\n raise ValueError('Bad time units input {}'.format(time_units))\\n # Check new length units\\n in_len = self.len_units\\n if len_units is None:\\n len_units = in_len\\n flag = _units.validate_units(len_units)\\n if flag == -1:\\n raise ValueError('Bad length units input {}'.format(len_units))\\n # Check new pumping rate units\\n in_pump = self.pump_units\\n if pump_units is None:\\n pump_units = in_pump\\n if same:\\n pump_units = \\\"%s3/%s\\\" % (len_units, time_units)\\n flag = _units.validate_units(pump_units)\\n if flag == -1:\\n raise ValueError('Bad pumping rate units input {}'.format(len_units))\\n\\n # Convert parameters units\\n for key, value in self.parameters.items():\\n if type(value) in [int, float]:\\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\\n # Convert pumping rate data\\n self.pumprate.convert_units(time_units, pump_units)\\n # Convert well data units\\n for i in range(self.well_count()):\\n self.wells[i].convert_units(time_units, len_units)\\n # Set input units\\n self.len_units = len_units\\n self.time_units = time_units\\n self.pump_units = pump_units\\n # End Function\",\n \"def test_wrong_argument_for_encoding(self):\\n with self.assertRaises(exceptions.WrongArgumentTypeError):\\n positional.encode(4.5, 10)\",\n \"def test_length_unknown_unit(self):\\n with self.assertRaises(ValueError):\\n METRIC_SYSTEM.length(5, 'fr')\",\n \"def test_unit(self):\\n self.assertEqual(DPTSignedRelativeValue.unit, \\\"\\\")\\n self.assertEqual(DPTPercentV8.unit, \\\"%\\\")\\n self.assertEqual(DPTValue1Count.unit, \\\"counter pulses\\\")\",\n \"def useUnits():\",\n \"def test_day_microseconds_wrong_type(self):\\n with self.assertRaises(ValueError):\\n utils.day_microseconds('dummy')\",\n \"def convert_from_to(from_unit, to_unit, quantity):\\n if not is_valid_unit(from_unit):\\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\\n if not is_valid_unit(to_unit):\\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]\",\n \"def test_invalid_value(self):\\n with self.assertRaises(TypeError):\\n METRIC_SYSTEM.length('25a', LENGTH_KILOMETERS)\\n with self.assertRaises(TypeError):\\n METRIC_SYSTEM.temperature('50K', TEMP_CELSIUS)\",\n \"def test_convert_amounts(self):\\n pass\",\n \"def convert_units(unt, origunits):\\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\\n units = origunits\\n convf = 1\\n else:\\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'met':\\n units = 'feet'\\n convf = 3.2808399\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'met' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'fee':\\n units = 'meters'\\n convf = 0.3048\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'kno':\\n units = 'meters/sec'\\n convf = 0.51444444\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'm/s':\\n units = 'knots'\\n convf = 1.9438445\\n else:\\n units = origunits\\n convf = 1\\n else:\\n error('Unknown units')\\n #\\n return units, convf\",\n \"def to_unit_validator(compatible_units):\\n def _to_unit_validator(quantity_str):\\n return process_unit_bearing_str(quantity_str, compatible_units)\\n return _to_unit_validator\",\n \"def process_unit_input(in_,\\n default_units: UnitLike = None,\\n convert: bool = False,\\n check_dims: bool = False,\\n copy: bool = True,\\n registry: unyt.UnitRegistry = None) -> unyt_array:\\n parser = UnitInputParser(default_units=default_units,\\n convert=convert,\\n check_dims=check_dims,\\n copy=copy,\\n registry=registry)\\n return parser.parse(in_)\",\n \"def test_convert():\",\n \"def convert_physical_value(value: str, unit: str = None, strip_units=True):\\n\\n # Ensure that the value is a string\\n value = str(value).strip()\\n\\n # Error on blank values\\n if not value:\\n raise ValidationError(_('No value provided'))\\n\\n ureg = get_unit_registry()\\n error = ''\\n\\n try:\\n # Convert to a quantity\\n val = ureg.Quantity(value)\\n\\n if unit:\\n\\n if is_dimensionless(val):\\n # If the provided value is dimensionless, assume that the unit is correct\\n val = ureg.Quantity(value, unit)\\n else:\\n # Convert to the provided unit (may raise an exception)\\n val = val.to(unit)\\n\\n # At this point we *should* have a valid pint value\\n # To double check, look at the maginitude\\n float(ureg.Quantity(val.magnitude).magnitude)\\n except (TypeError, ValueError, AttributeError):\\n error = _('Provided value is not a valid number')\\n except (pint.errors.UndefinedUnitError, pint.errors.DefinitionSyntaxError):\\n error = _('Provided value has an invalid unit')\\n if unit:\\n error += f' ({unit})'\\n\\n except pint.errors.DimensionalityError:\\n error = _('Provided value could not be converted to the specified unit')\\n if unit:\\n error += f' ({unit})'\\n\\n except Exception as e:\\n error = _('Error') + ': ' + str(e)\\n\\n if error:\\n raise ValidationError(error)\\n\\n # Calculate the \\\"magnitude\\\" of the value, as a float\\n # If the value is specified strangely (e.g. as a fraction or a dozen), this can cause isuses\\n # So, we ensure that it is converted to a floating point value\\n # If we wish to return a \\\"raw\\\" value, some trickery is required\\n if unit:\\n magnitude = ureg.Quantity(val.to(unit)).magnitude\\n else:\\n magnitude = ureg.Quantity(val.to_base_units()).magnitude\\n\\n magnitude = float(ureg.Quantity(magnitude).to_base_units().magnitude)\\n\\n if strip_units:\\n return magnitude\\n elif unit or val.units:\\n return ureg.Quantity(magnitude, unit or val.units)\\n else:\\n return ureg.Quantity(magnitude)\",\n \"def test_to_int(self):\\n self.assertEqual(to_int(u\\\"3\\\"), 3)\\n self.assertEqual(to_int(u\\\"asdf\\\"), 0)\\n self.assertEqual(to_int(None), 0)\",\n \"def test_temperature_unknown_unit(self):\\n with self.assertRaises(ValueError):\\n METRIC_SYSTEM.temperature(5, 'K')\",\n \"def test_inches_invalid_input(self):\\n result = inch_to_cm(\\\"--\\\")\\n self.assertIsNone(result)\",\n \"def spice_unit_convert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result /= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result *= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\\n result *= numeric(spice_unit_unconvert([part, \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n else:\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n newvalue = numeric(valuet[1]) * 0.01\\n return str(newvalue)\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def conversionNotPossibleException(valueType: cern.japc.value.ValueType, valueType2: cern.japc.value.ValueType) -> cern.japc.value.ValueConversionException:\\n ...\",\n \"def convert_string_to_unit(s):\\n \\n if \\\":\\\" not in s:\\n match = UNIT_RE.match(s)\\n if match:\\n s = \\\"%s:%s\\\"%match.groups()\\n \\n return Unit(s)\",\n \"def convert_same_units(self):\\n # Convert pumping rate data\\n pump_units = \\\"%s3/%s\\\" % (self.len_units, self.time_units)\\n flag = _units.validate_units(pump_units)\\n if flag == 2:\\n self.pumprate.convert_units(self.time_units, pump_units)\\n self.pump_units = pump_units\",\n \"def test_convert_likelihood_invalid_input():\\n with pytest.raises(ValueError) as err:\\n convert_likelihood(to='aaa', ts=30, df=4)\\n assert \\\"Invalid parameter `to`: aaa\\\" in str(err)\\n\\n with pytest.raises(ValueError) as err:\\n convert_likelihood(to='ts')\\n assert \\\"You have to pass exactly one\\\" in str(err)\\n\\n with pytest.raises(ValueError) as err:\\n convert_likelihood(to='ts', ts=99, chi2=99)\\n assert \\\"You have to pass exactly one\\\" in str(err)\\n\\n with pytest.raises(ValueError) as err:\\n convert_likelihood(to='significance', ts=99)\\n assert 'You have to specify the number of degrees of freedom via the `df` parameter.' in str(err)\",\n \"def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)\",\n \"def test_dummy(self, data):\\r\\n source, expected = data\\r\\n result = self.converter.convert(source)\\r\\n self.assertUnicodeEquals(result, expected)\",\n \"def convert_units(self, time_units=None, len_units=None):\\n in_time = self.time_units\\n # Check new time units\\n if time_units is None:\\n time_units = in_time\\n flag = _units.validate_units(time_units)\\n if flag == -1:\\n raise ValueError('Bad time units input {}'.format(time_units))\\n # Check new length units\\n in_len = self.len_units\\n if len_units is None:\\n len_units = in_len\\n flag = _units.validate_units(len_units)\\n if flag == -1:\\n raise ValueError('Bad length units input {}'.format(len_units))\\n # Convert parameters units\\n for key, value in self.parameters.items():\\n if type(value) in [int, float]:\\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\\n # Convert drawdown data\\n self.drawdown.convert_units(time_units, len_units)\\n # Convert associate data units\\n for i in range(self.data_count()):\\n if self.data[i].dtype == 1: # drawdown units\\n data_units = len_units\\n elif self.data[i].dtype == 2: # first derivative units\\n data_units = len_units + \\\"/\\\" + time_units\\n elif self.data[i].dtype == 3: # second derivative units\\n data_units = len_units + \\\"/\\\" + time_units + \\\"2\\\"\\n self.data[i].convert_units(time_units, data_units)\\n self.len_units = len_units\\n self.time_units = time_units\\n # End Function\",\n \"def test_unit_conversion_compatible(self):\\n self.orography_cube.convert_units('ft')\\n probability_cube = self.plugin_instance.process(self.orography_cube)\\n self.assertIsInstance(probability_cube, iris.cube.Cube)\\n self.assertSequenceEqual(probability_cube.shape,\\n self.reference_cube.shape)\",\n \"def test_check_wrong_argument_type(self, number, base):\\n with self.assertRaises(exceptions.WrongArgumentTypeError):\\n positional.decode(number, base)\",\n \"def test_bad_values(self):\\n self.assertOK([60])\\n self.assertRaisesInternalError([59.9])\\n self.assertRaisesInternalError([''])\\n self.assertRaisesInternalError([';'])\\n self.assertRaisesInternalError(['('])\\n self.assertRaisesInternalError([None])\",\n \"def doconvert(self, error_on_negative=True):\\n if error_on_negative and self.amt < 0:\\n raise ValueError('Amount must be a positive number')\\n conv = (self.amt * self._getuval(self.ufrom)) / self._getuval(self.uto)\\n return conv\",\n \"def _to(\\n value: Union[\\\"Value\\\", \\\"ValueArray\\\"], units: Union[Unit, str], inplace: bool\\n) -> Any:\\n if value.units == units:\\n return value\\n\\n if value.units is None:\\n raise RuntimeError(\\\"Cannot convert with units=None\\\")\\n\\n try:\\n units = next(\\n imp_unit\\n for imp_unit in value.implemented_units\\n if units.lower() in imp_unit.aliases\\n )\\n\\n except StopIteration:\\n raise TypeError(\\n f\\\"No viable unit conversion from {value.units} -> {units}\\\"\\n )\\n\\n if not (isinstance(value, Value) or isinstance(value, ValueArray)):\\n raise ValueError(\\n f\\\"Cannot convert {value} to new units. Must be one of\\\"\\n f\\\" Value of ValueArray\\\"\\n )\\n\\n if isinstance(value, Value) and inplace:\\n raise ValueError(\\n \\\"Cannot modify a value inplace as floats are immutable\\\"\\n )\\n\\n # Convert to the base unit, then to the new units\\n c = float(units.conversion / value.units.conversion)\\n\\n new_value = value if inplace else value.copy()\\n new_value *= c\\n new_value.units = units\\n\\n return None if inplace else new_value\",\n \"def test_conversion_type(self):\\r\\n self.assertRaises(ValueError, convert_fastaqual_fastq,\\r\\n self.fasta_file_path, self.qual_file_path, conversion_type='soijdfl',\\r\\n output_directory=self.output_dir)\",\n \"def try_consume_units(self, units):\\n pass\",\n \"def test_convert_with_blank_input():\\n assert convert(\\\"\\\") == \\\"\\\"\",\n \"def test_convertCharToInt_bad_value(self):\\n self.assertRaises(ValueError, rules.convertCharToInt, 'qq')\",\n \"def convert_units(self, units):\\n self.unit_array = self.unit_array.to(units)\",\n \"def test_creation_float():\\n with pytest.raises(ValueError) as __:\\n value = 42.30474\\n __ = param.Integer(value=value)\",\n \"def test_human_size_units_to_base(self):\\n self.assertEqual(human_size_units_to_base(1), 1)\\n self.assertEqual(human_size_units_to_base('1'), 1)\\n self.assertEqual(human_size_units_to_base('1b'), 1)\\n self.assertEqual(human_size_units_to_base('1k'), 1000)\\n self.assertEqual(human_size_units_to_base('1kb'), 1000)\\n self.assertEqual(human_size_units_to_base('1kib'), 1024)\\n self.assertEqual(human_size_units_to_base('1KiB'), 1024)\\n self.assertEqual(human_size_units_to_base('1KiB 1b'), 1025)\\n self.assertEqual(human_size_units_to_base('1M'), 1000000)\\n self.assertEqual(human_size_units_to_base('1Mi'), 1024*1024)\\n self.assertEqual(human_size_units_to_base('1G'), 1000000000)\\n self.assertEqual(human_size_units_to_base('1T'), 1000000000000)\\n self.assertRaisesRegex(ValueError, 'Bad unit \\\"a\\\" in size parameter \\\"1a\\\".', human_size_units_to_base, '1a')\",\n \"def test_invalid_component_values():\\n\\n # Test Arrhenius-type reaction when nonsensical R value (e.g. string)\\n xml_filename = \\\"tests/test_xml_files/unit_conversion_fail_arr_invalidR.xml\\\"\\n with pytest.raises(ValueError):\\n parser = XMLParser(xml_filename, convert_to_SI_units=False)\\n\\n # Test Arrhenius-type reaction when nonsensical A value (e.g. string)\\n xml_filename = \\\"tests/test_xml_files/unit_conversion_fail_arr_A.xml\\\"\\n with pytest.raises(ValueError):\\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\\n\\n # Test Arrhenius-type reaction when nonsensical E value (e.g. string)\\n xml_filename = \\\"tests/test_xml_files/unit_conversion_fail_arr_E.xml\\\"\\n with pytest.raises(ValueError):\\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\\n\\n # Test modified Arrhenius-type reaction when nonsensical R value (e.g. string)\\n xml_filename = \\\"tests/test_xml_files/unit_conversion_fail_modarr_invalidR.xml\\\"\\n with pytest.raises(ValueError):\\n parser = XMLParser(xml_filename, convert_to_SI_units=False)\\n\\n # Test modified Arrhenius-type reaction when nonsensical A value (e.g. string)\\n xml_filename = \\\"tests/test_xml_files/unit_conversion_fail_modarr_A.xml\\\"\\n with pytest.raises(ValueError):\\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\\n\\n # Test modified Arrhenius-type reaction when nonsensical b value (e.g. string) \\n xml_filename = \\\"tests/test_xml_files/unit_conversion_fail_modarr_b.xml\\\"\\n with pytest.raises(ValueError):\\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\\n\\n # Test modified Arrhenius-type reaction when nonsensical E value (e.g. string)\\n xml_filename = \\\"tests/test_xml_files/unit_conversion_fail_modarr_E.xml\\\"\\n with pytest.raises(ValueError):\\n parser = XMLParser(xml_filename, convert_to_SI_units=True)\",\n \"def test_invalid_argument_type(self):\\n t = TruthTable('A or B')\\n\\n with self.assertRaises(InvalidArgumentTypeError):\\n t.equivalent_to(float())\\n\\n with self.assertRaises(InvalidArgumentTypeError):\\n t.equivalent_to(None)\",\n \"def cast_value(value, unit):\\n if isinstance(value, u.Quantity):\\n return value.to(unit)\\n return value * unit\",\n \"def test_buoy_format2():\\n with pytest.raises(AssertionError) as err_info:\\n Check_BuoyDC.check_buoy_format(buoy_format_fail_2)\\n assert str(err_info.value) == 'Input length incorrect, see instructions'\",\n \"def test_process_args_should_reject_fractional_resolution_values(self, arg_dict):\\n self.use_resolution_val(arg_dict, 600.1)\\n with pytest.raises(TypeError):\\n change_resolution.process_args(arg_dict)\",\n \"def test_cast_string_failure(self) -> None:\\n self.flag.flag_type = None\\n self.assertRaises(ValueError, self.flag.cast_string, '42')\",\n \"def check_units(self, secondary_spectrum):\\n\\n if self.unit != secondary_spectrum.unit:\\n raise ValueError('Spectra are in different units!')\",\n \"def test_jy_to_mk_freq_wrong_units():\\n test_fq = np.array([0.1]) * units.m\\n pytest.raises(units.UnitsError, utils.jy_to_mk, test_fq)\",\n \"def test_different_units(self):\\n self.temperature.convert_units(\\\"celsius\\\")\\n self.relative_humidity.convert_units(\\\"1\\\")\\n self.pressure.convert_units(\\\"kPa\\\")\\n result = WetBulbTemperature().create_wet_bulb_temperature_cube(\\n self.temperature, self.relative_humidity, self.pressure\\n )\\n self.assertArrayAlmostEqual(result.data, self.expected_wbt_data, decimal=3)\\n self.assertEqual(result.units, Unit(\\\"K\\\"))\",\n \"def test_cast_non_numeric_false():\\n assert _currency_column_to_numeric(\\\"10 dollars\\\", {\\\"foo\\\": 42}) == \\\"10\\\"\",\n \"def SBMLUnitsConverter_init():\\n return _libsbml.SBMLUnitsConverter_init()\",\n \"def unit_arg(option, opt, value, parser):\\n actual = from_units(value)\\n if actual is None:\\n parser.error('Invalid value \\\\'%s\\\\' for %s' % (value, opt))\\n setattr(parser.values, option.dest, actual)\",\n \"def test_float():\\n assert float(Quantity(1, unit('m'))) == float(1)\",\n \"def convert_units(data, units):\\n # Build the dictionary of units conversions\\n convert = {'m' : [1.0, 0., 'm'], \\n 'meter' : [1.0, 0., 'm'], \\n 'deg C' : [1.0, 273.15, 'K'], \\n 'Celsius' : [1.0, 273.15, 'K'], \\n 'K' : [1.0, 0., 'K'],\\n 'db' : [1.e4, 101325., 'Pa'], \\n 'Pa' : [1.0, 0., 'Pa'],\\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \\n 'S/m': [1.0, 0., 'S/m'],\\n 'mS/m' : [1.e-3, 0., 'S/m'],\\n 'psu': [1.0, 0., 'psu'], \\n 'salinity': [1.0, 0., 'psu'], \\n 'kg/m^3': [1.0, 0., 'kg/m^3'], \\n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \\n 'm/s': [1.0, 0., 'm/s'], \\n 'mg/l': [1.e-3, 0., 'kg/m^3'],\\n 'meter second-1' : [1.0, 0., 'm/s'],\\n 'm.s-1' : [1.0, 0., 'm/s'],\\n 'pH units' : [1.0, 0., 'pH units'],\\n 'MPa' : [1.e6, 0., 'Pa'],\\n '--' : [1.0, 0., '--'],\\n 'mD' : [9.869233e-16, 0., 'm^2'],\\n 'um' : [1.e-6, 0., 'm'],\\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\\n 'wt.%' : [10., 0., 'psu'],\\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\\n 'm^2' : [1., 0., 'm^2'],\\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \\n } \\n \\n # Make sure the data are a numpy array and the units are a list\\n if isinstance(data, float) or isinstance(data, int):\\n data = np.array([data])\\n if isinstance(data, list):\\n data = np.array(data)\\n if isinstance(units, str) or isinstance(units, unicode):\\n units = [units]\\n if units == None:\\n units = ['']\\n \\n # Make sure you can slice through the columns: must be two-dimensional\\n sh = data.shape\\n data = np.atleast_2d(data)\\n \\n # Allow conversion of a row of data if all of the same unit\\n if len(units) == 1 and data.shape[1] > 1:\\n data = data.transpose()\\n \\n # Create an emtpy array to hold the output\\n out_data = np.zeros(data.shape)\\n out_units = []\\n \\n # Convert the units\\n for i in range(len(units)):\\n try:\\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\\\\n convert[units[i]][1]\\n out_units += [convert[units[i]][2]]\\n except KeyError:\\n print('Do not know how to convert %s to mks units' % units[i])\\n print('Continuing without converting these units...')\\n out_data[:,i] = data[:,i]\\n out_units += units[i]\\n \\n # Return the converted data in the original shape\\n out_data = np.reshape(out_data, sh, 'C')\\n return (out_data, out_units)\",\n \"def spice_unit_unconvert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item / spice_unit_unconvert([parts[1], 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result /= spice_unit_unconvert([parts[1], 1.0], restrict)\\n return result\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = spice_unit_unconvert([parts[0], valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item * spice_unit_unconvert([parts[1], 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result *= spice_unit_unconvert([parts[1], 1.0], restrict)\\n return result\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = spice_unit_unconvert([part, valuet[1]], restrict)\\n if isinstance(result, list):\\n result = list(item * spice_unit_unconvert([part, 1.0],\\n\\t\\t\\trestrict) for item in result)\\n else:\\n result *= spice_unit_unconvert([part, 1.0], restrict)\\n return result\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n if isinstance(valuet[1], list):\\n return list(item / prefixtypes[prerec] for item in valuet[1])\\n else:\\n return valuet[1] / prefixtypes[prerec]\\n else:\\n if isinstance(valuet[1], list):\\n return list(item / prefixtypes[prerec] for item in valuet[1])\\n else:\\n return valuet[1] / prefixtypes[prerec]\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n if isinstance(valuet[1], list):\\n return list(item * 100 for item in valuet[1])\\n else:\\n return valuet[1] * 100\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def unit(cls, val):\\n raise NotImplementedError\",\n \"def test_type_errors():\\n\\n\\ttry:\\n\\t\\ttransmissions = compute_transmissions(cal_directory, lines = 3.0)\\n\\texcept TypeError:\\n\\t\\ttry:\\n\\t\\t\\ttransmissions = compute_transmissions(cal_directory, calibrator = 300.0)\\n\\t\\texcept TypeError:\\n\\t\\t\\tassert True\\n\\t\\telse:\\n\\t\\t\\tassert False\\n\\telse:\\n\\t\\tassert False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80642945","0.76356244","0.7445948","0.7313819","0.7179943","0.68142354","0.6702233","0.67012995","0.648865","0.64848894","0.637458","0.63654095","0.63062716","0.63011336","0.6265371","0.6258366","0.62375414","0.6222837","0.61793447","0.6161228","0.6158621","0.61132884","0.6108588","0.6108034","0.6088413","0.6084264","0.60842395","0.60749453","0.60545397","0.6052672","0.60521144","0.5999238","0.59900266","0.5967363","0.59477025","0.59369344","0.5934079","0.59252656","0.5911685","0.5905803","0.589648","0.58899385","0.5885683","0.5873252","0.587307","0.5858579","0.5849918","0.5844023","0.5841192","0.58030075","0.57854384","0.57832533","0.5780507","0.57795423","0.5751468","0.5749885","0.57340276","0.5712466","0.5708071","0.57036155","0.570127","0.5694075","0.5686791","0.5678894","0.56636083","0.5656749","0.5651518","0.56458056","0.5644474","0.564226","0.56307185","0.56004363","0.5593791","0.5590715","0.5565189","0.5564167","0.55604506","0.5551261","0.55470175","0.5540134","0.5536904","0.5531554","0.5526594","0.5520704","0.5508647","0.5498126","0.54960626","0.5494221","0.54924864","0.5492058","0.549059","0.5488988","0.5488832","0.54852486","0.5471732","0.5471639","0.5466252","0.5461522","0.5457347","0.54542094"],"string":"[\n \"0.80642945\",\n \"0.76356244\",\n \"0.7445948\",\n \"0.7313819\",\n \"0.7179943\",\n \"0.68142354\",\n \"0.6702233\",\n \"0.67012995\",\n \"0.648865\",\n \"0.64848894\",\n \"0.637458\",\n \"0.63654095\",\n \"0.63062716\",\n \"0.63011336\",\n \"0.6265371\",\n \"0.6258366\",\n \"0.62375414\",\n \"0.6222837\",\n \"0.61793447\",\n \"0.6161228\",\n \"0.6158621\",\n \"0.61132884\",\n \"0.6108588\",\n \"0.6108034\",\n \"0.6088413\",\n \"0.6084264\",\n \"0.60842395\",\n \"0.60749453\",\n \"0.60545397\",\n \"0.6052672\",\n \"0.60521144\",\n \"0.5999238\",\n \"0.59900266\",\n \"0.5967363\",\n \"0.59477025\",\n \"0.59369344\",\n \"0.5934079\",\n \"0.59252656\",\n \"0.5911685\",\n \"0.5905803\",\n \"0.589648\",\n \"0.58899385\",\n \"0.5885683\",\n \"0.5873252\",\n \"0.587307\",\n \"0.5858579\",\n \"0.5849918\",\n \"0.5844023\",\n \"0.5841192\",\n \"0.58030075\",\n \"0.57854384\",\n \"0.57832533\",\n \"0.5780507\",\n \"0.57795423\",\n \"0.5751468\",\n \"0.5749885\",\n \"0.57340276\",\n \"0.5712466\",\n \"0.5708071\",\n \"0.57036155\",\n \"0.570127\",\n \"0.5694075\",\n \"0.5686791\",\n \"0.5678894\",\n \"0.56636083\",\n \"0.5656749\",\n \"0.5651518\",\n \"0.56458056\",\n \"0.5644474\",\n \"0.564226\",\n \"0.56307185\",\n \"0.56004363\",\n \"0.5593791\",\n \"0.5590715\",\n \"0.5565189\",\n \"0.5564167\",\n \"0.55604506\",\n \"0.5551261\",\n \"0.55470175\",\n \"0.5540134\",\n \"0.5536904\",\n \"0.5531554\",\n \"0.5526594\",\n \"0.5520704\",\n \"0.5508647\",\n \"0.5498126\",\n \"0.54960626\",\n \"0.5494221\",\n \"0.54924864\",\n \"0.5492058\",\n \"0.549059\",\n \"0.5488988\",\n \"0.5488832\",\n \"0.54852486\",\n \"0.5471732\",\n \"0.5471639\",\n \"0.5466252\",\n \"0.5461522\",\n \"0.5457347\",\n \"0.54542094\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7108532"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":14872,"cells":{"query":{"kind":"string","value":"Convert units with custom factors."},"document":{"kind":"string","value":"def test_convert_unit_with_custom_factor(test_df):\n # unit conversion with custom factor\n df = get_units_test_df(test_df)\n exp = pd.Series([1.0, 6.0, 1.0, 6.0, 4.0, 14.0], name=\"value\")\n assert_converted_units(df, \"EJ/yr\", \"foo\", exp, factor=2)"},"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 convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6","def convert_units(data, units):\n # Build the dictionary of units conversions\n convert = {'m' : [1.0, 0., 'm'], \n 'meter' : [1.0, 0., 'm'], \n 'deg C' : [1.0, 273.15, 'K'], \n 'Celsius' : [1.0, 273.15, 'K'], \n 'K' : [1.0, 0., 'K'],\n 'db' : [1.e4, 101325., 'Pa'], \n 'Pa' : [1.0, 0., 'Pa'],\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \n 'S/m': [1.0, 0., 'S/m'],\n 'mS/m' : [1.e-3, 0., 'S/m'],\n 'psu': [1.0, 0., 'psu'], \n 'salinity': [1.0, 0., 'psu'], \n 'kg/m^3': [1.0, 0., 'kg/m^3'], \n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \n 'm/s': [1.0, 0., 'm/s'], \n 'mg/l': [1.e-3, 0., 'kg/m^3'],\n 'meter second-1' : [1.0, 0., 'm/s'],\n 'm.s-1' : [1.0, 0., 'm/s'],\n 'pH units' : [1.0, 0., 'pH units'],\n 'MPa' : [1.e6, 0., 'Pa'],\n '--' : [1.0, 0., '--'],\n 'mD' : [9.869233e-16, 0., 'm^2'],\n 'um' : [1.e-6, 0., 'm'],\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\n 'wt.%' : [10., 0., 'psu'],\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\n 'm^2' : [1., 0., 'm^2'],\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \n } \n \n # Make sure the data are a numpy array and the units are a list\n if isinstance(data, float) or isinstance(data, int):\n data = np.array([data])\n if isinstance(data, list):\n data = np.array(data)\n if isinstance(units, str) or isinstance(units, unicode):\n units = [units]\n if units == None:\n units = ['']\n \n # Make sure you can slice through the columns: must be two-dimensional\n sh = data.shape\n data = np.atleast_2d(data)\n \n # Allow conversion of a row of data if all of the same unit\n if len(units) == 1 and data.shape[1] > 1:\n data = data.transpose()\n \n # Create an emtpy array to hold the output\n out_data = np.zeros(data.shape)\n out_units = []\n \n # Convert the units\n for i in range(len(units)):\n try:\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\n convert[units[i]][1]\n out_units += [convert[units[i]][2]]\n except KeyError:\n print('Do not know how to convert %s to mks units' % units[i])\n print('Continuing without converting these units...')\n out_data[:,i] = data[:,i]\n out_units += units[i]\n \n # Return the converted data in the original shape\n out_data = np.reshape(out_data, sh, 'C')\n return (out_data, out_units)","def convert_units(self, units):\n self.unit_array = self.unit_array.to(units)","def convert(self, value, units, newunits):\n return value * self._units[units] / self._units[newunits]","def _convert_unit(self, unit):\n if unit in self.units:\n return self.units[unit]\n elif unit in unit_map:\n return unit_map[unit]\n else:\n raise SBMLError('Unit not recognized: ' + str(unit))","def unit_convert(df, coln1, coln2, unit, conversion_factor, coln3):\n df.loc[df[coln2] == unit, coln1] = conversion_factor * df[coln3]\n return df","def convert_units(unt, origunits):\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\n units = origunits\n convf = 1\n else:\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'met':\n units = 'feet'\n convf = 3.2808399\n else:\n units = origunits\n convf = 1\n else:\n if 'met' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'fee':\n units = 'meters'\n convf = 0.3048\n else:\n units = origunits\n convf = 1\n else:\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'kno':\n units = 'meters/sec'\n convf = 0.51444444\n else:\n units = origunits\n convf = 1\n else:\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\n if origunits[0:3] == 'm/s':\n units = 'knots'\n convf = 1.9438445\n else:\n units = origunits\n convf = 1\n else:\n error('Unknown units')\n #\n return units, convf","def unit_converter(val, from_u, to_u):\n\tconverter = {'b':0, 'k':1, 'm':2, 'g':3, 't':4}\n\tif converter[from_u] < converter[to_u]:\n\t\tval = float(val)\n\t\tfor _ in range(converter[to_u] - converter[from_u]):\n\t\t\tval = val/1024\n\telse:\n\t\tfor _ in range(converter[from_u] - converter[to_u]):\n\t\t\tval = val * 1024\n\t\t\t\n\treturn val","def convertUnits(self, varname, arr):\n if varname == \"SPDQ\" or varname == \"PHQ\":\n return arr*2.5e6/1000.\n return arr","def convert_units(celsius_value, units):\n if units == 0:\n return celsius_value\n if units == 1:\n return celsius_value * 1.8 + 32\n return celsius_value + 273.15","def units_to_fits(unit):\n if unit is None:\n unit = Unit('')\n return unit.to_string(\"fits\").upper()","def to_unit(self, unit):\n unit = _find_unit(unit)\n self.value = _convert_value(self.value, self.unit, unit)\n self.unit = unit","def useUnits():","def convert_unit(self, time_unit):\r\n\r\n self.time_unit = time_unit\r\n self._conversion_factor = time_unit_conversion[time_unit]","def conv(old='auto', new='auto'):\n if old == new:\n return 1.\n for unittype in [lenunits, angunits, timunits, masunits, eneunits]:\n if old in unittype and new in unittype:\n return unittype[new] / unittype[old]\n\n raise ValueError('Units \\'{}\\' and \\'{}\\' unrecognized or '\n 'not of same unit type'.format(old, new))","def convert_units(cube, units):\n try:\n cube.convert_units(units)\n except ValueError:\n if not _try_special_conversions(cube, units):\n raise\n\n return cube","def convert_unit(size_in_bytes, unit):\n if unit == 'KB':\n return size_in_bytes/1024\n elif unit == 'MB':\n return size_in_bytes/(1024*1024)\n elif unit == 'GB':\n return size_in_bytes/(1024*1024*1024)\n else:\n return size_in_bytes","def test_convert_compatible_units(self):\n result = convert_units(self.arr, 'degC')\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\n expected_units = cf_units.Unit('degC')\n self.assertEquals(result.units, expected_units)\n self.assertArrayEqual(result.data, expected_data)","def convertUnit(*args, fromUnit: AnyStr=\"\", toUnit: AnyStr=\"\", **kwargs)->float:\n pass","def unit(x,convert_to=\"px\",from_unit=\"px\"):\n assert convert_to in UNITS, \"Cannot convert to unknown unit: %s\" % convert_to\n assert from_unit in UNITS, \"Cannot from unknown unit: %s\" % from_unit\n return float(x)*UNITS[convert_to]/UNITS[from_unit]","def convert_qty (qty,unit,ing) :\n portion_presence = False\n try :\n div = re.search(r\"[^ \\w]\", qty).start()\n portion = float(qty[div-1]) / float(qty[div+1])\n qty_float=portion\n portion_presence = True\n qty = qty[:div-1]\n except :\n try : \n qty_float = float(qty)\n except :\n qty_float = 10\n\n if portion_presence == True :\n if len(qty) > 0 :\n qty_float += float(qty[:div-2])\n \n #use the unit to have in ml\n #qty_float*=conversion_unit[unit]\n \n #convert in grammes with the database of density\n #qty_float*=density[ing]\n \n return qty_float","def unit_conversion(thing, units, length=False):\n if 'n/a' == thing:\n return 'n/a'\n try:\n thing = round(thing * CONVERSION[units][0 + length], 2)\n except:\n thing = 'fubar'\n return thing, CONVERSION[units][2 + length]","def _fix_units(cube, definition):\n\n if cube.var_name != 'pr':\n cube.convert_units(definition.units)","def convert(self):\n return _libsbml.SBMLUnitsConverter_convert(self)","def _get_unit_factor(self, unit: str) -> np.ndarray:\n\n unit_factors = {\n 'vx': np.array((1, 1, 1)),\n 'nm': np.array(self.parameters.scale),\n 'um': np.array(self.parameters.scale)/1000\n }\n assert unit in unit_factors.keys(), 'Invalid unit'\n unit_factor = unit_factors[unit]\n\n return unit_factor","def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\n return process_unit_input(value, units, convert=True, registry=registry).v","def cast_value(value, unit):\n if isinstance(value, u.Quantity):\n return value.to(unit)\n return value * unit","def convert(x, unit1, unit2):\r\n return conversions[unit1][unit2](x)","def convert_to(self, units: str) -> None:\n if self.units == units:\n return\n\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\n msg = f\"\"\"Not a valid unit conversion. Valid destination units:\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\"\"\"\n raise ValueError(msg)\n\n if self.units == \"celsius\" and units == \"fahrenheit\":\n self._celsius_to_fahrenheit()\n elif self.units == \"m/s\" and units == \"km/h\":\n self._mps_to_kph()\n elif self.units == \"m/s\" and units == \"mph\":\n self._mps_to_mph()\n else:\n raise ValueError(\"Not a valid unit conversion.\")","def convert_from_to(from_unit, to_unit, quantity):\n if not is_valid_unit(from_unit):\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\n if not is_valid_unit(to_unit):\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]","def get_units(self,):\n self.UNITS = {'pressure':'Pa',}\n return","def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)","def to(self, new_unit, **kwargs):\n new_unit = u.Unit(new_unit)\n return self * (self.unit.to(new_unit, **kwargs) * new_unit / self.unit)","def spice_unit_convert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result /= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result *= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\n result *= numeric(spice_unit_unconvert([part, \"1.0\"], restrict))\n return str(result)\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n else:\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n newvalue = numeric(valuet[1]) * 0.01\n return str(newvalue)\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def tempConvert(temp, unit):\n if unit == 'F':\n celsius = (temp - 32) * 5 / 9\n return celsius\n else:\n return temp","def normalize_units(data):\n for obj in data:\n obj['unit'] = normalize_units_function(obj.get('unit', ''))\n # for param in ds.get('parameters', {}).values():\n # if 'unit' in param:\n # param['unit'] = normalize_units_function(param['unit'])\n return data","def get_units(self):\r\n msg = struct.pack('>2B', 56, 14)\r\n response = self.query(msg)\r\n\r\n if response[1] == 2:\r\n units = 'A'\r\n to_nm_multiplier = 1 / 10\r\n elif response[1] == 1:\r\n units = 'nm'\r\n to_nm_multiplier = 1\r\n elif response[1] == 0:\r\n units = 'um'\r\n to_nm_multiplier = 1000\r\n else:\r\n raise ValueError('Units not recognised.')\r\n\r\n # Save results locally too for quick re-use\r\n self._current_units = units\r\n self._current_to_nm_multiplier = to_nm_multiplier\r\n\r\n return units, to_nm_multiplier","def unitsDetector(self, num):\n try:\n num = int(num)\n except:\n sys.exit('Invalid input! Method only takes ints or floats.')\n \n digits = 0\n while num > 1:\n num /= 10\n digits += 1\n \n digits -= 1\n ind = digits // 3\n units = {3: 'B', 2: 'M', 1: 'K', 0: ''}[ind]\n \n return 10 ** (ind * 3), units","def convert_to_unit(self, data, unit):\n\n res = OrderedDict()\n\n # Loop over data and overwrite\n for ch in data:\n _idx = self.channels.index(ch)\n # Get data, scale and type of channel\n val, scale, _type = data[ch], self.daq_setup['devices']['adc']['ro_scales'][_idx], self.daq_setup['devices']['adc']['types'][_idx]\n # Adjust scale in case we're looking at SEM's sum signal; in this case current is multiplied by factor of 4\n scale *= 1 if _type != 'sem_sum' else 4\n\n res[ch] = val / 5.0 * scale * 1e-9 if unit == 'A' else val * 5.0 / 1e-9 / scale\n\n return res","def convert(self):\n return _libsbml.SBMLInferUnitsConverter_convert(self)","def to_units(number):\n unit = 0\n while number >= 1024.:\n unit += 1\n number = number / 1024.\n if unit == len(UNITS) - 1:\n break\n if unit:\n return '%.2f%s' % (number, UNITS[unit])\n return '%d' % number","def get_unit(scale):\n scale2unit = { 1e-9: 'nm',\n 1e-6: u'\\N{MICRO SIGN}m', #or hex id (lookup): u'\\u00B5'\n 1e-3: 'mm',\n 0.01: 'cm',\n 0.1:'dm',\n 1:'m',\n 1000:'km',\n # time\n 8.6400e4:'day',\n 3.1536e7:'yr',\n 3.1536e10:'ka',\n 3.1536e13:'Ma',\n #Pressure\n 1e9: 'GPa',\n 1e6: 'MPa',\n }\n return scale2unit[scale]","def _conversion_factor_internal(unit: str):\n return globals()[unit]","def tranfer_unit(number):\n count = 0\n unit_name = \"\"\n if 2 ** 20 > number > 2 ** 10:\n unit_name = \"Kb\"\n count = 1\n elif 2 ** 30 > number > 2 ** 20:\n unit_name = \"Mb\"\n count = 2\n elif number > 2 ** 30:\n unit_name = \"Gb\"\n count = 3\n else:\n unit_name = \"b\"\n if count != 0:\n unit_number = round(number / ((2 ** 10) ** count), 2)\n else:\n unit_number = round(number, 2)\n unit_str = \"{num}{name}\".format(num=unit_number, name=unit_name)\n return unit_str","def _convert_value(self, value, unit, axis):\n if hasattr(value, 'units'):\n return value.to(unit).magnitude\n else:\n return self._reg.Quantity(value, axis.get_units()).to(unit).magnitude","def convert_units(value, from_unit, to_unit, **args):\n\n # Check if units can be converted\n if not can_convert(from_unit, to_unit):\n return '[!] Units cannot be converted\\n'\n\n # Extract the numeric value from the string\n decimal_places = 2 # Set the default value of precision\n if \".\" in str(value):\n decimal_places = len(str(value)[str(value).index('.') + 1:])\n\n # Return the value if units are the same\n if from_unit == to_unit:\n return str(value) + \" \" + get_si(to_unit)\n\n responses = [\n check_time(value, from_unit, to_unit, decimal_places), # Time units\n check_metric_imperial(\n value,\n from_unit,\n to_unit,\n decimal_places), # Metric and Imperial units\n check_digital_storage(\n value,\n from_unit,\n to_unit,\n decimal_places\n ) # Digital storage units\n ]\n\n for response in responses:\n if response:\n return response\n\n # actually convert the units\n try:\n return str(round(convert(from_unit, to_unit, float(value), **args), decimal_places)) + \" \" + get_si(to_unit)\n except RequireAdditionalParamError as e:\n additional_unit = input(\"\\n[*] Enter an additional unit (choose between \" + str(e.additional_params) + \"): \")\n additional_value = float(input(\"\\n[*] Enter the value: \"))\n return convert_units(value, from_unit, to_unit, **{additional_unit: additional_value})\n except ConversionError as e:\n print(e.reason)","def convert_F_units(F, lbda, in_unit='cgs', out_unit='si'):\n\n if in_unit == 'cgs':\n new_F = (F*1e23*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == 'cgsA':\n new_F = (F*1e27*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == 'si':\n new_F = (F*1e26*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\n elif in_unit == \"jy\":\n new_F=F\n else:\n msg = \"in_unit not recognized, try either 'cgs', 'si' or 'jy'.\"\n raise TypeError(msg) \n if out_unit == 'jy':\n return new_F\n elif out_unit == 'cgs':\n return new_F*1e-23*c.c.value*1e6/np.power(lbda,2)\n elif out_unit == 'si':\n return new_F*1e-26*c.c.value*1e6/np.power(lbda,2)\n else:\n msg = \"out_unit not recognized, try either 'cgs', 'si' or 'jy'.\"\n raise TypeError(msg)","def _replace_units(original_units, values_by_name):\n q = 1\n for arg_name, exponent in original_units.items():\n q = q * values_by_name[arg_name] ** exponent\n\n return getattr(q, \"_units\", UnitsContainer({}))","def fits_to_units(unit_str):\n unit_lookup = {\n 'meters': 'm',\n 'meter': 'm',\n 'degrees': 'deg',\n 'degree': 'deg',\n 'hz': 'Hz',\n 'hertz': 'Hz',\n 'second': 's',\n 'sec': 's',\n 'secs': 's',\n 'days': 'd',\n 'day': 'd',\n 'steradians': 'sr',\n 'steradian': 'sr',\n 'radians': 'rad',\n 'radian': 'rad',\n 'jy': 'Jy',\n 'au': 'AU',\n }\n\n try:\n new_units = \"\"\n\n if unit_str is None:\n unit_str = ''\n unit_str = unit_str.lower()\n unit_list = unit_str.split(\"/\")\n\n for uu in unit_list:\n if uu.endswith(\"s\") and len(uu) > 1:\n uu = uu[:-1]\n corrected_unit = unit_lookup.get(uu, uu)\n new_units += corrected_unit\n new_units += \" / \"\n new_units = new_units[:-3]\n unit = Unit(new_units)\n return unit\n\n except ValueError:\n warnings.warn(\"Unknown unit: %s\" % new_units, UnitWarning)\n return UnrecognizedUnit(unit_str)","def test_unit_conversion(self):\n self.cube_uv_down.convert_units(\"kW m-2\")\n scale_factor = 1.0\n expected = np.full_like(\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\n )\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\n self.assertArrayEqual(result.data, expected)","def set_units(self, units):\n self.units = units","def test_convert_same_unit():\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5","def convert_units(self, time_units=None, len_units=None):\n in_time = self.time_units\n # Check new time units\n if time_units is None:\n time_units = in_time\n flag = _units.validate_units(time_units)\n if flag == -1:\n raise ValueError('Bad time units input {}'.format(time_units))\n # Check new length units\n in_len = self.len_units\n if len_units is None:\n len_units = in_len\n flag = _units.validate_units(len_units)\n if flag == -1:\n raise ValueError('Bad length units input {}'.format(len_units))\n # Convert parameters units\n for key, value in self.parameters.items():\n if type(value) in [int, float]:\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\n # Convert drawdown data\n self.drawdown.convert_units(time_units, len_units)\n # Convert associate data units\n for i in range(self.data_count()):\n if self.data[i].dtype == 1: # drawdown units\n data_units = len_units\n elif self.data[i].dtype == 2: # first derivative units\n data_units = len_units + \"/\" + time_units\n elif self.data[i].dtype == 3: # second derivative units\n data_units = len_units + \"/\" + time_units + \"2\"\n self.data[i].convert_units(time_units, data_units)\n self.len_units = len_units\n self.time_units = time_units\n # End Function","def unit(self,unit_str,unit_scale):\n self.units[unit_str] = unit_scale\n return self","def convert(obj, unit, axis):\r\n return obj","def _get_unit_factor(cls, unit):\n try:\n if isinstance(unit, str):\n unit = cls.UNIT_FACTOR_NAMES[unit]\n return cls.UNIT_FACTORS[unit]\n except KeyError:\n raise UnsupportedUnitError()","def fix_coord_units(cat, RA, DEC):\n cat[RA].info.unit = u.deg\n cat[DEC].info.unit = u.deg\n return cat","def to_units(self, amount):\n return int(amount / self.price)","def resolve_units(obj, _):\n return obj.units.decode()","def preprocess_sub_units(self):\n if self.unit == \"char\":\n self.preprocess_char()\n elif self.unit == \"char-ngram\":\n self.preprocess_char_ngram()\n elif self.unit == \"morpheme\":\n self.preprocess_morpheme()\n elif self.unit == \"oracle\":\n self.preprocess_oracle()\n else:\n sys.exit(\"Unknown unit\")","def reduce_unit(self, guide_unit=None):\n key = (self.unit, guide_unit)\n if key in Quantity._reduce_cache:\n (unit, value_factor) = Quantity._reduce_cache[key]\n else:\n value_factor = 1.0\n canonical_units = {} # dict of dimensionTuple: (Base/ScaledUnit, exponent)\n # Bias result toward guide units\n if guide_unit != None:\n for u, exponent in guide_unit.iter_base_or_scaled_units():\n d = u.get_dimension_tuple()\n if d not in canonical_units:\n canonical_units[d] = [u, 0]\n for u, exponent in self.unit.iter_base_or_scaled_units():\n d = u.get_dimension_tuple()\n # Take first unit found in a dimension as canonical\n if d not in canonical_units:\n canonical_units[d] = [u, exponent]\n else:\n value_factor *= (u.conversion_factor_to(canonical_units[d][0])**exponent)\n canonical_units[d][1] += exponent\n new_base_units = {}\n for d in canonical_units:\n u, exponent = canonical_units[d]\n if exponent != 0:\n assert u not in new_base_units\n new_base_units[u] = exponent\n # Create new unit\n if len(new_base_units) == 0:\n unit = dimensionless\n else:\n unit = Unit(new_base_units)\n # There might be a factor due to unit conversion, even though unit is dimensionless\n # e.g. suppose unit is meter/centimeter\n if unit.is_dimensionless():\n unit_factor = unit.conversion_factor_to(dimensionless)\n if unit_factor != 1.0:\n value_factor *= unit_factor\n # print \"value_factor = %s\" % value_factor\n unit = dimensionless\n Quantity._reduce_cache[key] = (unit, value_factor)\n # Create Quantity, then scale (in case value is a container)\n # That's why we don't just scale the value.\n result = Quantity(self._value, unit)\n if value_factor != 1.0:\n # __mul__ strips off dimensionless, if appropriate\n result = result * value_factor\n if unit.is_dimensionless():\n assert unit is dimensionless # should have been set earlier in this method\n if is_quantity(result):\n result = result._value\n return result","def assign_unit(self):\n self.units = {}\n for unit in RADIAL_UNITS:\n if unit.REPR == \"2th_deg\":\n self.units[unit] = self.tth_deg\n elif unit.REPR == \"2th_rad\":\n self.units[unit] = self.tth_rad\n elif unit.REPR == \"q_nm^-1\":\n self.units[unit] = self.q_nm\n elif unit.REPR == \"q_A^-1\":\n self.units[unit] = self.q_A\n elif unit.REPR == \"r_mm\":\n self.units[unit] = self.r_mm\n else:\n logger.warning(\"Unit unknown to GUI %s\" % unit)","def add_special_conversion(self, from_units, to_units, converter):\n self.special_conversions[(from_units, to_units)] = converter","def set_distance_units(value=np.NaN, from_units='mm', to_units='cm'):\n if from_units == to_units:\n return value\n\n coeff = 1\n if from_units == 'cm':\n if to_units == 'mm':\n coeff = 10\n elif to_units == 'm':\n coeff = 0.01\n else:\n raise ValueError(\"to_units not supported ['cm','m','mm']!\")\n elif from_units == 'mm':\n if to_units == 'cm':\n coeff = 0.1\n elif to_units == 'm':\n coeff = 0.001\n else:\n raise ValueError(\"to_units not supported ['cm','m','mm']!\")\n elif from_units == 'm':\n if to_units == 'mm':\n coeff = 1000\n elif to_units == 'cm':\n coeff = 100\n else:\n raise ValueError(\"to_units not supported ['cm','m','mm']!\")\n else:\n raise ValueError(\"to_units not supported ['cm','m','mm']!\")\n\n return coeff * value","def to_base_unit(val: float, unit: str = \"\") -> float:\n unit_scalar = UNITS.get(unit, None)\n if not unit_scalar:\n raise UnknownUnitError(f\"Unit '{unit}' is not supported\")\n\n return val * unit_scalar","def update_units(self):\n unit_var_value = self.view.vars['unit'].get()\n if unit_var_value == 'm3ph':\n self.minran_u_label.config(text='m³/h')\n self.maxran_u_label.config(text='m³/h')\n self.points_tview.heading('vflow', text='Przepływ [m³/h]', anchor=tk.CENTER)\n elif unit_var_value == 'lps':\n self.minran_u_label.config(text='l/s')\n self.maxran_u_label.config(text='l/s')\n self.points_tview.heading('vflow', text='Przepływ [l/s]', anchor=tk.CENTER)\n self.view.vars['pump_eff_min'].convert_unit(unit_var_value)\n self.view.vars['pump_eff_max'].convert_unit(unit_var_value)\n self.view.vars['pump_characteristic'].convert_unit(unit_var_value)","def unit_string(value, units, prefu={'M', 'L', 'J', 'C', 'V', 'N', 'W', 'Pa'}):\r\n if units == unity or not value:\r\n return value, \"\", \"\"\r\n SIunits = list(units)\r\n derived = dict((pu, 0) for pu in prefu if sum(abs(t) for t in unitquant[pu].units) > 1)\r\n while derived:\r\n (improvement, d, sign) = try_all_derived(SIunits, derived)\r\n if improvement <= 0:\r\n break\r\n derived[d] += sign\r\n for i, used_in_derived in enumerate(unitquant[d].units):\r\n SIunits[i] -= used_in_derived * sign\r\n value /= unitquant[d].number ** sign\r\n allunits = dict([(x, derived[x]) for x in derived if derived[x]])\r\n DUS = [du for du in allunits if du in derived]\r\n for DU in DUS: # choose between atm and mmHg etc.\r\n choices = [pu for pu in derived if unitquant[pu].units == unitquant[DU].units]\r\n if not choices:\r\n break\r\n quality = [(abs(math_log10(abs(value) / (unitquant[c].number / unitquant[DU].number) ** allunits[DU]) - 1.0), c)\r\n for c in choices]\r\n best = min(quality)[1]\r\n if best != DU:\r\n allunits[best] = allunits[DU]\r\n value /= (unitquant[best].number / unitquant[DU].number) ** allunits[best]\r\n allunits[DU] = 0\r\n for i, SIU in enumerate(SIunit_symbols): # choose between m, cm, mm etc.\r\n if not SIunits[i]:\r\n continue\r\n choices = [pu for pu in prefu if (pu not in derived) and unitquant[pu].units[i]]\r\n if not choices:\r\n break\r\n quality = [(abs(math_log10(abs(value) / unitquant[c].number ** (SIunits[i] / unitquant[c].units[i])) - 1.0), c)\r\n for c in choices]\r\n best = min(quality)[1]\r\n allunits[best] = Fraction(SIunits[i], unitquant[best].units[i])\r\n if allunits[best].denominator == 1:\r\n allunits[best] = int(allunits[best])\r\n SIunits[i] = 0\r\n value /= unitquant[best].number ** allunits[best]\r\n for u, d in zip(SIunit_symbols, SIunits):\r\n if d:\r\n allunits[u] = d\r\n poslist = [(u, exp) for u, exp in allunits.items() if exp > 0]\r\n neglist = [(u, -exp) for u, exp in allunits.items() if exp < 0]\r\n return value, poslist, neglist","def SBMLUnitsConverter_init():\n return _libsbml.SBMLUnitsConverter_init()","def infer_original_units(self, dimensions):\n dimensions = units.Unit(dimensions)\n d = dimensions.dimensional_project(\n self._file_units_system + [\"a\", \"h\"])\n new_unit = reduce(lambda x, y: x * y, [\n a ** b for a, b in zip(self._file_units_system, d)])\n return new_unit","def convert_mass(self, event):\n try:\n #Compare other unit to one unit(kilograms)\n current_value, current_unit = float(\"0\" + str(self.v.get())), self.dropdown.get()\n unit_comp = {\"Earth masses\": 5.97219e+24, \"Solar masses\": 1.9890000000000002e+30, \"carats\": 0.0002, \"cental\": 45.359237, \"decagrams\": 0.01, \"femtograms\": 1e-18, \"grains\": 6.479891000000001e-05, \"grams\": 0.001, \"hectograms\": 0.1, \"hundredweights\": 50.802345, \"kilograms\": 1.0, \"kilotonnes\": 1000000.0, \"megatonnes\": 1000000000.0, \"micrograms\": 1e-09, \"milligrams\": 1e-06, \"nanograms\": 1e-12, \"ounces(US & UK)\": 0.02835, \"ounces(precious metals)\": 0.031103, \"picograms\": 1e-15, \"pounds(US & UK)\": 0.453592, \"pounds(precious metals)\": 0.373242, \"slugs\": 14.593903, \"stones\": 6.350293, \"tonnes(metric)\": 1000.0, \"tons(UK)\": 1016.046909, \"tons(US)\": 907.18474}\n value_comp, printer = current_value * unit_comp[current_unit], \"\"\n unit_list = sorted(unit_comp.keys())\n unit_list.remove(current_unit)\n for unit in unit_list:\n printer += \"To %s \" % unit + \" \" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\"\", \"\\n\"][unit_list[-1] != unit]\n except ValueError: #In case user enter the other type of value, not Int or Float\n printer = \"Value is invalid.\"\n self.print_text(printer)","def convert_units(data, hdr, conv_to = \"surf_br\"):\n \n data_unit = hdr[\"SIGUNIT\"]\n \n if \"Jy/pix\" in data_unit:\n # pixel size in rad\n px_x = abs(hdr[\"CDELT1\"])*2*np.pi/360\n px_y = abs(hdr[\"CDELT2\"])*2*np.pi/360\n \n #pixel size in arcsec\n \n px_x = abs(hdr[\"CDELT1\"])*3600\n px_y = abs(hdr[\"CDELT2\"])*3600\n conversion_factor = 1000/(px_x*px_y)\n \n unit_label = \"mJy/arcsec^2\"\n \n #in case we want to convert to units flux, we need to multiply by the size (in steradians) of a pixel.\n if conv_to == \"flux\":\n conversion_factor*=abs(hdr[\"CDELT1\"])*abs(hdr[\"CDELT2\"])*(2*np.pi/360)**2\n unit_label = \"mJy\"\n \n data *= conversion_factor\n hdr[\"SIGUNIT\"] = unit_label\n else:\n print(\"\\t[WARNING]\\t \"+data_unit+\" conversion not yet implemented. No conversion performed.\")\n \n return data, hdr","def units_to_pixels(self,units_):\n if type(units_) == str and units_.lower() in [\"fwhm\",\"psf\"]:\n units_ = self.fwhm\n\n return super(Image, self).units_to_pixels(units_, target=self.target)","def convert_same_units(self):\n # Convert pumping rate data\n pump_units = \"%s3/%s\" % (self.len_units, self.time_units)\n flag = _units.validate_units(pump_units)\n if flag == 2:\n self.pumprate.convert_units(self.time_units, pump_units)\n self.pump_units = pump_units","def test_change_units(self):\n s = State(\"water\", T=Q_(100, \"degC\"), p=Q_(1.0, \"atm\"), units=\"EE\")\n assert s.units == \"EE\"\n s.units = \"SI\"\n assert s.units == \"SI\"\n assert s.cv.units == \"kilojoule / kelvin / kilogram\"\n assert s.cp.units == \"kilojoule / kelvin / kilogram\"\n assert s.s.units == \"kilojoule / kelvin / kilogram\"\n assert s.h.units == \"kilojoule / kilogram\"\n assert s.T.units == \"degree_Celsius\"\n assert s.u.units == \"kilojoule / kilogram\"\n assert s.v.units == \"meter ** 3 / kilogram\"\n assert s.p.units == \"bar\"","def __convert_to_mm(self, value, in_devunit=True):\r\n if in_devunit:\r\n value /= self.DEVUNIT_RATIO\r\n return value","def units(inventory):\n return inventory.reduce(convert.get_units)","def native_unit_of_measurement(self) -> str:\n return f\"{CURRENCY_CENT}/{UnitOfVolume.LITERS}\"","def normalize(self, factor):","def convert(value, unit, axis):\n converted_value = value\n if isinstance(unit, str) or isinstance(unit, Unit):\n unit = (unit,)\n if isinstance(value, (unyt_array, unyt_quantity)):\n converted_value = value.to(*unit)\n else:\n value_type = type(value)\n converted_value = []\n for obj in value:\n converted_value.append(obj.to(*unit))\n converted_value = value_type(converted_value)\n return converted_value","def convert_units(array, in_units=\"None\"):\n if in_units == \"None\" or in_units is None:\n return array\n else:\n raise Exception(\"Unsupported unit for bispectrum descriptors.\")","def units(self):\n pass","def convert_path_units(self, path_to_conv):\n\n converted_path = copy.deepcopy(path_to_conv) # TODO: figure out if this is the right way to do this- I have not yet understood how data should be handled here\n\n for i, coord in enumerate(converted_path):\n converted_path[i][0] = coord[0] / self.units_in_meter\n converted_path[i][1] = coord[1] / self.units_in_meter\n converted_path[i][2] = coord[2] / self.units_in_meter\n\n return converted_path","def to_axis_units(self, label, vals):\n if label in ['Hmolar', 'Smolar', 'Umolar', 'Dmolar', 'P']:\n return vals / 1000\n elif label in ['T']:\n return vals\n else:\n raise ValueError(label)","def _override_units_system(self):\n try:\n f = open(self.filename+\".units\")\n except OSError:\n return\n\n name_mapping = {'pos': 'distance', 'vel': 'velocity'}\n units_dict = {}\n\n for line in f:\n if (not line.startswith(\"#\")):\n if \":\" not in line:\n raise OSError(\"Unknown format for units file %r\"%(self.filename+\".units\"))\n else:\n t, u = list(map(str.strip,line.split(\":\")))\n t = name_mapping.get(t,t)\n units_dict[t] = u\n\n self.set_units_system(**units_dict)","def calc_unit_factor(self, ui_unit):\n # namedView = self.document.getroot().find(inkex.addNS('namedview', 'sodipodi'))\n # doc_units = self.getunittouu(str(1.0) + namedView.get(inkex.addNS('document-units', 'inkscape')))\n unit_factor = self.getunittouu(str(1.0) + ui_unit)\n return unit_factor","def convert_units(data, typec,fromm, to):\n cdata = []\n \n if typec == 'OPC_temporal':\n cdata = OPCtimetransform(data, to)\n elif typec == 'temporal':\n if isinstance(data[0], float):\n data = [str(i) for i in data]\n cdata = tt.convertTime(data, fromm, to)\n elif typec == 'units':\n for measure in data:\n cdata.append(conversion(measure, fromm, to))\n else:\n raise TypeError('Unknown or unsupported conversion tyoe: ' + typec)\n cdata = data\n \n return cdata","def convert(self, value, unit, axis):\n scaled = getattr(value, self.scale)\n if self.format in YMDHMS_FORMATS:\n return scaled.mjd\n elif self.format == \"byear_str\":\n return scaled.byear\n elif self.format == \"jyear_str\":\n return scaled.jyear\n else:\n return getattr(scaled, self.format)","def dim_unit_scaling(in_unit, out_unit):\n\n unit_vals = {\n 'nm': 1e-9,\n 'um': 1e-6,\n 'mm': 1e-3,\n 'cm': 1e-2,\n 'm': 1.0,\n 'km': 1e3,\n }\n\n if in_unit not in unit_vals:\n raise ValueError(\n 'Invalid input unit {}. Must be one of {}'.format(\n in_unit, list(unit_vals.keys())\n )\n )\n if out_unit not in unit_vals:\n raise ValueError(\n 'Invalid input unit {}. Must be one of {}'.format(\n in_unit, list(unit_vals.keys())\n )\n )\n\n return unit_vals[in_unit]/unit_vals[out_unit]","def parseUnits(value, units):\n\tn = len(value)\n\tfor i, c in enumerate(value):\n\t\tif c.isalpha():\n\t\t\tn = i\n\t\t\tbreak\n\n\tnumberStr = value[:n]\n\tnumber = float(numberStr)\n\n\tunitStr = value[n:]\n\tfor unit, multiplier in units:\n\t\tif unitStr == unit:\n\t\t\treturn int(multiplier * number)\n\n\traise ValueError('Unknown unit \"%s\"' % unitStr)","def convert_temp(orig_temp, units):\n switcher = {\n 'k': ((orig_temp - 32) * 5.0 / 9.0) + 273.15,\n 'c': (orig_temp - 32) * 5.0 / 9.0,\n 'f': orig_temp\n }\n temperature = switcher.get(units.lower())\n conversion = dict(original=orig_temp, units=units, temperature=temperature)\n return conversion","def original_units(self):\n self.physical_units(distance=self.infer_original_units('km'),\n velocity=self.infer_original_units('km s^-1'),\n mass=self.infer_original_units('Msol'), persistent=False)","def units(self, units):\n\n self._units = units","def units(self, units):\n\n self._units = units","def units(self, units):\n\n self._units = units","def to_meters(d, d_unit):\n if d_unit == UOM_M:\n dm = d\n elif d_unit == UOM_KM:\n dm = d * 1000\n elif d_unit == UOM_FEET:\n dm = feet2m(d)\n elif d_unit == UOM_SM:\n dm = SM2m(d)\n elif d_unit == UOM_NM:\n dm = NM2m(d)\n return dm","def _get_units(self, q) -> unyt.Unit:\n try:\n units = q.units\n except AttributeError:\n units = unyt.dimensionless\n return unyt.Unit(units, registry=self.registry)","def units(self, key):\n \n # Strip any operators\n _, key = get_operator(key)\n \n # Fill out aliases \n if key in component_from_alias:\n key = component_from_alias[key]\n elif key == 'E':\n key = 'electricField'\n elif key == 'B':\n key = 'magneticField' \n \n return pg_units(key)","def _add_converted_units(self, dataframe, parameter, key='VALUE'):\n convert_unit = self.parameters.get_converter(parameter)\n try:\n dataframe[key] = dataframe['DATA_VALUE'].apply(convert_unit)\n except KeyError:\n log.warn(\"Missing 'VALUE': no unit conversion.\")\n else:\n dataframe.unit = self.parameters.unit(parameter)","def convert_volume(self, event):\n try:\n #Compare other unit to one unit(cubic decimeters)\n current_value, current_unit = float(\"0\" + str(self.v.get())), self.dropdown.get()\n unit_comp = {\"acre foot\": 1233481.837548, \"barrels\": 158.987295, \"bushels(UK)\": 36.36872, \"bushels(US)\": 35.23907, \"centiliters\": 0.01, \"cubic centimeters\": 0.001, \"cubic decameters\": 1000000.0, \"cubic decimeters\": 1.0, \"cubic feet\": 28.316847, \"cubic inches\": 0.016387, \"cubic kilometers\": 1000000000000.0, \"cubic meters\": 1000.0, \"cubic mile\": 4168181825000.0, \"cubic millimeters\": 1e-06, \"cubic yards\": 764.554858, \"cups\": 0.236588, \"deciliters\": 0.1, \"dram\": 0.003697, \"dram(imperial)\": 0.003552, \"fluid ounces(US)\": 0.029574, \"fluid ounces(imperial)\": 0.028413, \"gallons(US,dry)\": 4.404884, \"gallons(US,liquid)\": 3.785412, \"gallons(imperial)\": 4.54609, \"gill(US)\": 0.118294, \"gill(imperial)\": 0.142065, \"liters\": 1.0, \"liters(1901-1964)\": 1.000028, \"microliters\": 1e-06, \"milliliters\": 0.001, \"nanoliters\": 1e-09, \"picoliters\": 1e-12, \"pints(US,dry)\": 0.55061, \"pints(US,liquid)\": 0.473176, \"pints(imperial)\": 0.568261, \"quarts(UK,dry)\": 1.101221, \"quarts(US,liquid)\": 0.946353, \"quarts(imperial)\": 1.136523, \"table spoons\": 0.014787, \"tea spoons\": 0.004929}\n value_comp, printer = current_value * unit_comp[current_unit], \"\"\n unit_list = sorted(unit_comp.keys())\n unit_list.remove(current_unit)\n for unit in unit_list:\n printer += \"To %s \" % unit + \" \" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\"\", \"\\n\"][unit_list[-1] != unit]\n except ValueError: #In case user enter the other type of value, not Int or Float\n printer = \"Value is invalid.\"\n self.print_text(printer)","def FormatUnits(value, baseTwo=False, baseUnit=''):\n\n prefixes = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']\n divisor = 1000\n if baseTwo:\n divisor = 1024\n\n for prefix in prefixes:\n if value < divisor:\n return \"{:.3f} {}{}\".format(value, prefix, baseUnit)\n value = value / divisor\n\n return \"{:.3f}Y{}\".format(value, prefix, baseUnit)"],"string":"[\n \"def convert_units(self):\\n for prod in (\\\"ier\\\", \\\"ier_inc_rain\\\"):\\n self.data[prod].data[:] /= 1e6\",\n \"def convert_units(data, units):\\n # Build the dictionary of units conversions\\n convert = {'m' : [1.0, 0., 'm'], \\n 'meter' : [1.0, 0., 'm'], \\n 'deg C' : [1.0, 273.15, 'K'], \\n 'Celsius' : [1.0, 273.15, 'K'], \\n 'K' : [1.0, 0., 'K'],\\n 'db' : [1.e4, 101325., 'Pa'], \\n 'Pa' : [1.0, 0., 'Pa'],\\n 'mg/m^3': [1.e-6, 0., 'kg/m^3'], \\n 'S/m': [1.0, 0., 'S/m'],\\n 'mS/m' : [1.e-3, 0., 'S/m'],\\n 'psu': [1.0, 0., 'psu'], \\n 'salinity': [1.0, 0., 'psu'], \\n 'kg/m^3': [1.0, 0., 'kg/m^3'], \\n 'kilogram meter-3': [1.0, 0., 'kg/m^3'], \\n 'm/s': [1.0, 0., 'm/s'], \\n 'mg/l': [1.e-3, 0., 'kg/m^3'],\\n 'meter second-1' : [1.0, 0., 'm/s'],\\n 'm.s-1' : [1.0, 0., 'm/s'],\\n 'pH units' : [1.0, 0., 'pH units'],\\n 'MPa' : [1.e6, 0., 'Pa'],\\n '--' : [1.0, 0., '--'],\\n 'mD' : [9.869233e-16, 0., 'm^2'],\\n 'um' : [1.e-6, 0., 'm'],\\n 'm/s 1e-9' : [1.e-9, 0., 'm/s'],\\n 'm/s 1e-7' : [1.e-7, 0., 'm/s'],\\n 'wt.%' : [10., 0., 'psu'],\\n '10^-15 m^2' : [1.e-15, 0., 'm^2'],\\n 'm^2' : [1., 0., 'm^2'],\\n 'kg/m^2/year' : [3.168808781402895e-08, 0., 'kg/m^2/s'] \\n } \\n \\n # Make sure the data are a numpy array and the units are a list\\n if isinstance(data, float) or isinstance(data, int):\\n data = np.array([data])\\n if isinstance(data, list):\\n data = np.array(data)\\n if isinstance(units, str) or isinstance(units, unicode):\\n units = [units]\\n if units == None:\\n units = ['']\\n \\n # Make sure you can slice through the columns: must be two-dimensional\\n sh = data.shape\\n data = np.atleast_2d(data)\\n \\n # Allow conversion of a row of data if all of the same unit\\n if len(units) == 1 and data.shape[1] > 1:\\n data = data.transpose()\\n \\n # Create an emtpy array to hold the output\\n out_data = np.zeros(data.shape)\\n out_units = []\\n \\n # Convert the units\\n for i in range(len(units)):\\n try:\\n out_data[:,i] = data[:,i] * convert[units[i]][0] + \\\\\\n convert[units[i]][1]\\n out_units += [convert[units[i]][2]]\\n except KeyError:\\n print('Do not know how to convert %s to mks units' % units[i])\\n print('Continuing without converting these units...')\\n out_data[:,i] = data[:,i]\\n out_units += units[i]\\n \\n # Return the converted data in the original shape\\n out_data = np.reshape(out_data, sh, 'C')\\n return (out_data, out_units)\",\n \"def convert_units(self, units):\\n self.unit_array = self.unit_array.to(units)\",\n \"def convert(self, value, units, newunits):\\n return value * self._units[units] / self._units[newunits]\",\n \"def _convert_unit(self, unit):\\n if unit in self.units:\\n return self.units[unit]\\n elif unit in unit_map:\\n return unit_map[unit]\\n else:\\n raise SBMLError('Unit not recognized: ' + str(unit))\",\n \"def unit_convert(df, coln1, coln2, unit, conversion_factor, coln3):\\n df.loc[df[coln2] == unit, coln1] = conversion_factor * df[coln3]\\n return df\",\n \"def convert_units(unt, origunits):\\n if unt[0:3] == origunits[0:3] | unt[0:3] == 'ori':\\n units = origunits\\n convf = 1\\n else:\\n if 'fee' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'met':\\n units = 'feet'\\n convf = 3.2808399\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'met' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'fee':\\n units = 'meters'\\n convf = 0.3048\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'm/s' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'kno':\\n units = 'meters/sec'\\n convf = 0.51444444\\n else:\\n units = origunits\\n convf = 1\\n else:\\n if 'kno' == unt[(((0:3 -1) -1) -1)]:\\n if origunits[0:3] == 'm/s':\\n units = 'knots'\\n convf = 1.9438445\\n else:\\n units = origunits\\n convf = 1\\n else:\\n error('Unknown units')\\n #\\n return units, convf\",\n \"def unit_converter(val, from_u, to_u):\\n\\tconverter = {'b':0, 'k':1, 'm':2, 'g':3, 't':4}\\n\\tif converter[from_u] < converter[to_u]:\\n\\t\\tval = float(val)\\n\\t\\tfor _ in range(converter[to_u] - converter[from_u]):\\n\\t\\t\\tval = val/1024\\n\\telse:\\n\\t\\tfor _ in range(converter[from_u] - converter[to_u]):\\n\\t\\t\\tval = val * 1024\\n\\t\\t\\t\\n\\treturn val\",\n \"def convertUnits(self, varname, arr):\\n if varname == \\\"SPDQ\\\" or varname == \\\"PHQ\\\":\\n return arr*2.5e6/1000.\\n return arr\",\n \"def convert_units(celsius_value, units):\\n if units == 0:\\n return celsius_value\\n if units == 1:\\n return celsius_value * 1.8 + 32\\n return celsius_value + 273.15\",\n \"def units_to_fits(unit):\\n if unit is None:\\n unit = Unit('')\\n return unit.to_string(\\\"fits\\\").upper()\",\n \"def to_unit(self, unit):\\n unit = _find_unit(unit)\\n self.value = _convert_value(self.value, self.unit, unit)\\n self.unit = unit\",\n \"def useUnits():\",\n \"def convert_unit(self, time_unit):\\r\\n\\r\\n self.time_unit = time_unit\\r\\n self._conversion_factor = time_unit_conversion[time_unit]\",\n \"def conv(old='auto', new='auto'):\\n if old == new:\\n return 1.\\n for unittype in [lenunits, angunits, timunits, masunits, eneunits]:\\n if old in unittype and new in unittype:\\n return unittype[new] / unittype[old]\\n\\n raise ValueError('Units \\\\'{}\\\\' and \\\\'{}\\\\' unrecognized or '\\n 'not of same unit type'.format(old, new))\",\n \"def convert_units(cube, units):\\n try:\\n cube.convert_units(units)\\n except ValueError:\\n if not _try_special_conversions(cube, units):\\n raise\\n\\n return cube\",\n \"def convert_unit(size_in_bytes, unit):\\n if unit == 'KB':\\n return size_in_bytes/1024\\n elif unit == 'MB':\\n return size_in_bytes/(1024*1024)\\n elif unit == 'GB':\\n return size_in_bytes/(1024*1024*1024)\\n else:\\n return size_in_bytes\",\n \"def test_convert_compatible_units(self):\\n result = convert_units(self.arr, 'degC')\\n expected_data = np.array([[-273.15, -272.15], [-271.15, -270.15]])\\n expected_units = cf_units.Unit('degC')\\n self.assertEquals(result.units, expected_units)\\n self.assertArrayEqual(result.data, expected_data)\",\n \"def convertUnit(*args, fromUnit: AnyStr=\\\"\\\", toUnit: AnyStr=\\\"\\\", **kwargs)->float:\\n pass\",\n \"def unit(x,convert_to=\\\"px\\\",from_unit=\\\"px\\\"):\\n assert convert_to in UNITS, \\\"Cannot convert to unknown unit: %s\\\" % convert_to\\n assert from_unit in UNITS, \\\"Cannot from unknown unit: %s\\\" % from_unit\\n return float(x)*UNITS[convert_to]/UNITS[from_unit]\",\n \"def convert_qty (qty,unit,ing) :\\n portion_presence = False\\n try :\\n div = re.search(r\\\"[^ \\\\w]\\\", qty).start()\\n portion = float(qty[div-1]) / float(qty[div+1])\\n qty_float=portion\\n portion_presence = True\\n qty = qty[:div-1]\\n except :\\n try : \\n qty_float = float(qty)\\n except :\\n qty_float = 10\\n\\n if portion_presence == True :\\n if len(qty) > 0 :\\n qty_float += float(qty[:div-2])\\n \\n #use the unit to have in ml\\n #qty_float*=conversion_unit[unit]\\n \\n #convert in grammes with the database of density\\n #qty_float*=density[ing]\\n \\n return qty_float\",\n \"def unit_conversion(thing, units, length=False):\\n if 'n/a' == thing:\\n return 'n/a'\\n try:\\n thing = round(thing * CONVERSION[units][0 + length], 2)\\n except:\\n thing = 'fubar'\\n return thing, CONVERSION[units][2 + length]\",\n \"def _fix_units(cube, definition):\\n\\n if cube.var_name != 'pr':\\n cube.convert_units(definition.units)\",\n \"def convert(self):\\n return _libsbml.SBMLUnitsConverter_convert(self)\",\n \"def _get_unit_factor(self, unit: str) -> np.ndarray:\\n\\n unit_factors = {\\n 'vx': np.array((1, 1, 1)),\\n 'nm': np.array(self.parameters.scale),\\n 'um': np.array(self.parameters.scale)/1000\\n }\\n assert unit in unit_factors.keys(), 'Invalid unit'\\n unit_factor = unit_factors[unit]\\n\\n return unit_factor\",\n \"def convert(value, units: UnitLike, registry: unyt.UnitRegistry = None):\\n return process_unit_input(value, units, convert=True, registry=registry).v\",\n \"def cast_value(value, unit):\\n if isinstance(value, u.Quantity):\\n return value.to(unit)\\n return value * unit\",\n \"def convert(x, unit1, unit2):\\r\\n return conversions[unit1][unit2](x)\",\n \"def convert_to(self, units: str) -> None:\\n if self.units == units:\\n return\\n\\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\\n msg = f\\\"\\\"\\\"Not a valid unit conversion. Valid destination units:\\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\\\"\\\"\\\"\\n raise ValueError(msg)\\n\\n if self.units == \\\"celsius\\\" and units == \\\"fahrenheit\\\":\\n self._celsius_to_fahrenheit()\\n elif self.units == \\\"m/s\\\" and units == \\\"km/h\\\":\\n self._mps_to_kph()\\n elif self.units == \\\"m/s\\\" and units == \\\"mph\\\":\\n self._mps_to_mph()\\n else:\\n raise ValueError(\\\"Not a valid unit conversion.\\\")\",\n \"def convert_from_to(from_unit, to_unit, quantity):\\n if not is_valid_unit(from_unit):\\n raise ValueError('Invalid from_unit: {}. Cannot convert.'.format(from_unit))\\n if not is_valid_unit(to_unit):\\n raise ValueError('Invalid to_unit: {}. Cannot convert.'.format(to_unit))\\n return quantity * CONVERSIONS_AMERICAN[from_unit][to_unit]\",\n \"def get_units(self,):\\n self.UNITS = {'pressure':'Pa',}\\n return\",\n \"def convert_units(src_unit: Union[str, float], tgt_unit: Union[str, float]):\\n return _parse_unit(src_unit) / _parse_unit(tgt_unit)\",\n \"def to(self, new_unit, **kwargs):\\n new_unit = u.Unit(new_unit)\\n return self * (self.unit.to(new_unit, **kwargs) * new_unit / self.unit)\",\n \"def spice_unit_convert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result /= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result *= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\\n result *= numeric(spice_unit_unconvert([part, \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n else:\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n newvalue = numeric(valuet[1]) * 0.01\\n return str(newvalue)\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def tempConvert(temp, unit):\\n if unit == 'F':\\n celsius = (temp - 32) * 5 / 9\\n return celsius\\n else:\\n return temp\",\n \"def normalize_units(data):\\n for obj in data:\\n obj['unit'] = normalize_units_function(obj.get('unit', ''))\\n # for param in ds.get('parameters', {}).values():\\n # if 'unit' in param:\\n # param['unit'] = normalize_units_function(param['unit'])\\n return data\",\n \"def get_units(self):\\r\\n msg = struct.pack('>2B', 56, 14)\\r\\n response = self.query(msg)\\r\\n\\r\\n if response[1] == 2:\\r\\n units = 'A'\\r\\n to_nm_multiplier = 1 / 10\\r\\n elif response[1] == 1:\\r\\n units = 'nm'\\r\\n to_nm_multiplier = 1\\r\\n elif response[1] == 0:\\r\\n units = 'um'\\r\\n to_nm_multiplier = 1000\\r\\n else:\\r\\n raise ValueError('Units not recognised.')\\r\\n\\r\\n # Save results locally too for quick re-use\\r\\n self._current_units = units\\r\\n self._current_to_nm_multiplier = to_nm_multiplier\\r\\n\\r\\n return units, to_nm_multiplier\",\n \"def unitsDetector(self, num):\\n try:\\n num = int(num)\\n except:\\n sys.exit('Invalid input! Method only takes ints or floats.')\\n \\n digits = 0\\n while num > 1:\\n num /= 10\\n digits += 1\\n \\n digits -= 1\\n ind = digits // 3\\n units = {3: 'B', 2: 'M', 1: 'K', 0: ''}[ind]\\n \\n return 10 ** (ind * 3), units\",\n \"def convert_to_unit(self, data, unit):\\n\\n res = OrderedDict()\\n\\n # Loop over data and overwrite\\n for ch in data:\\n _idx = self.channels.index(ch)\\n # Get data, scale and type of channel\\n val, scale, _type = data[ch], self.daq_setup['devices']['adc']['ro_scales'][_idx], self.daq_setup['devices']['adc']['types'][_idx]\\n # Adjust scale in case we're looking at SEM's sum signal; in this case current is multiplied by factor of 4\\n scale *= 1 if _type != 'sem_sum' else 4\\n\\n res[ch] = val / 5.0 * scale * 1e-9 if unit == 'A' else val * 5.0 / 1e-9 / scale\\n\\n return res\",\n \"def convert(self):\\n return _libsbml.SBMLInferUnitsConverter_convert(self)\",\n \"def to_units(number):\\n unit = 0\\n while number >= 1024.:\\n unit += 1\\n number = number / 1024.\\n if unit == len(UNITS) - 1:\\n break\\n if unit:\\n return '%.2f%s' % (number, UNITS[unit])\\n return '%d' % number\",\n \"def get_unit(scale):\\n scale2unit = { 1e-9: 'nm',\\n 1e-6: u'\\\\N{MICRO SIGN}m', #or hex id (lookup): u'\\\\u00B5'\\n 1e-3: 'mm',\\n 0.01: 'cm',\\n 0.1:'dm',\\n 1:'m',\\n 1000:'km',\\n # time\\n 8.6400e4:'day',\\n 3.1536e7:'yr',\\n 3.1536e10:'ka',\\n 3.1536e13:'Ma',\\n #Pressure\\n 1e9: 'GPa',\\n 1e6: 'MPa',\\n }\\n return scale2unit[scale]\",\n \"def _conversion_factor_internal(unit: str):\\n return globals()[unit]\",\n \"def tranfer_unit(number):\\n count = 0\\n unit_name = \\\"\\\"\\n if 2 ** 20 > number > 2 ** 10:\\n unit_name = \\\"Kb\\\"\\n count = 1\\n elif 2 ** 30 > number > 2 ** 20:\\n unit_name = \\\"Mb\\\"\\n count = 2\\n elif number > 2 ** 30:\\n unit_name = \\\"Gb\\\"\\n count = 3\\n else:\\n unit_name = \\\"b\\\"\\n if count != 0:\\n unit_number = round(number / ((2 ** 10) ** count), 2)\\n else:\\n unit_number = round(number, 2)\\n unit_str = \\\"{num}{name}\\\".format(num=unit_number, name=unit_name)\\n return unit_str\",\n \"def _convert_value(self, value, unit, axis):\\n if hasattr(value, 'units'):\\n return value.to(unit).magnitude\\n else:\\n return self._reg.Quantity(value, axis.get_units()).to(unit).magnitude\",\n \"def convert_units(value, from_unit, to_unit, **args):\\n\\n # Check if units can be converted\\n if not can_convert(from_unit, to_unit):\\n return '[!] Units cannot be converted\\\\n'\\n\\n # Extract the numeric value from the string\\n decimal_places = 2 # Set the default value of precision\\n if \\\".\\\" in str(value):\\n decimal_places = len(str(value)[str(value).index('.') + 1:])\\n\\n # Return the value if units are the same\\n if from_unit == to_unit:\\n return str(value) + \\\" \\\" + get_si(to_unit)\\n\\n responses = [\\n check_time(value, from_unit, to_unit, decimal_places), # Time units\\n check_metric_imperial(\\n value,\\n from_unit,\\n to_unit,\\n decimal_places), # Metric and Imperial units\\n check_digital_storage(\\n value,\\n from_unit,\\n to_unit,\\n decimal_places\\n ) # Digital storage units\\n ]\\n\\n for response in responses:\\n if response:\\n return response\\n\\n # actually convert the units\\n try:\\n return str(round(convert(from_unit, to_unit, float(value), **args), decimal_places)) + \\\" \\\" + get_si(to_unit)\\n except RequireAdditionalParamError as e:\\n additional_unit = input(\\\"\\\\n[*] Enter an additional unit (choose between \\\" + str(e.additional_params) + \\\"): \\\")\\n additional_value = float(input(\\\"\\\\n[*] Enter the value: \\\"))\\n return convert_units(value, from_unit, to_unit, **{additional_unit: additional_value})\\n except ConversionError as e:\\n print(e.reason)\",\n \"def convert_F_units(F, lbda, in_unit='cgs', out_unit='si'):\\n\\n if in_unit == 'cgs':\\n new_F = (F*1e23*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == 'cgsA':\\n new_F = (F*1e27*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == 'si':\\n new_F = (F*1e26*np.power(lbda,2))/(c.c.value*1e6) # convert to jy\\n elif in_unit == \\\"jy\\\":\\n new_F=F\\n else:\\n msg = \\\"in_unit not recognized, try either 'cgs', 'si' or 'jy'.\\\"\\n raise TypeError(msg) \\n if out_unit == 'jy':\\n return new_F\\n elif out_unit == 'cgs':\\n return new_F*1e-23*c.c.value*1e6/np.power(lbda,2)\\n elif out_unit == 'si':\\n return new_F*1e-26*c.c.value*1e6/np.power(lbda,2)\\n else:\\n msg = \\\"out_unit not recognized, try either 'cgs', 'si' or 'jy'.\\\"\\n raise TypeError(msg)\",\n \"def _replace_units(original_units, values_by_name):\\n q = 1\\n for arg_name, exponent in original_units.items():\\n q = q * values_by_name[arg_name] ** exponent\\n\\n return getattr(q, \\\"_units\\\", UnitsContainer({}))\",\n \"def fits_to_units(unit_str):\\n unit_lookup = {\\n 'meters': 'm',\\n 'meter': 'm',\\n 'degrees': 'deg',\\n 'degree': 'deg',\\n 'hz': 'Hz',\\n 'hertz': 'Hz',\\n 'second': 's',\\n 'sec': 's',\\n 'secs': 's',\\n 'days': 'd',\\n 'day': 'd',\\n 'steradians': 'sr',\\n 'steradian': 'sr',\\n 'radians': 'rad',\\n 'radian': 'rad',\\n 'jy': 'Jy',\\n 'au': 'AU',\\n }\\n\\n try:\\n new_units = \\\"\\\"\\n\\n if unit_str is None:\\n unit_str = ''\\n unit_str = unit_str.lower()\\n unit_list = unit_str.split(\\\"/\\\")\\n\\n for uu in unit_list:\\n if uu.endswith(\\\"s\\\") and len(uu) > 1:\\n uu = uu[:-1]\\n corrected_unit = unit_lookup.get(uu, uu)\\n new_units += corrected_unit\\n new_units += \\\" / \\\"\\n new_units = new_units[:-3]\\n unit = Unit(new_units)\\n return unit\\n\\n except ValueError:\\n warnings.warn(\\\"Unknown unit: %s\\\" % new_units, UnitWarning)\\n return UnrecognizedUnit(unit_str)\",\n \"def test_unit_conversion(self):\\n self.cube_uv_down.convert_units(\\\"kW m-2\\\")\\n scale_factor = 1.0\\n expected = np.full_like(\\n self.cube_uv_down.data, dtype=np.float32, fill_value=0.1\\n )\\n result = calculate_uv_index(self.cube_uv_down, scale_factor)\\n self.assertArrayEqual(result.data, expected)\",\n \"def set_units(self, units):\\n self.units = units\",\n \"def test_convert_same_unit():\\n assert pressure_util.convert(2, PRESSURE_PA, PRESSURE_PA) == 2\\n assert pressure_util.convert(3, PRESSURE_HPA, PRESSURE_HPA) == 3\\n assert pressure_util.convert(4, PRESSURE_MBAR, PRESSURE_MBAR) == 4\\n assert pressure_util.convert(5, PRESSURE_INHG, PRESSURE_INHG) == 5\",\n \"def convert_units(self, time_units=None, len_units=None):\\n in_time = self.time_units\\n # Check new time units\\n if time_units is None:\\n time_units = in_time\\n flag = _units.validate_units(time_units)\\n if flag == -1:\\n raise ValueError('Bad time units input {}'.format(time_units))\\n # Check new length units\\n in_len = self.len_units\\n if len_units is None:\\n len_units = in_len\\n flag = _units.validate_units(len_units)\\n if flag == -1:\\n raise ValueError('Bad length units input {}'.format(len_units))\\n # Convert parameters units\\n for key, value in self.parameters.items():\\n if type(value) in [int, float]:\\n self.parameters[key] = _units.units_conversion(value, in_len, len_units)\\n # Convert drawdown data\\n self.drawdown.convert_units(time_units, len_units)\\n # Convert associate data units\\n for i in range(self.data_count()):\\n if self.data[i].dtype == 1: # drawdown units\\n data_units = len_units\\n elif self.data[i].dtype == 2: # first derivative units\\n data_units = len_units + \\\"/\\\" + time_units\\n elif self.data[i].dtype == 3: # second derivative units\\n data_units = len_units + \\\"/\\\" + time_units + \\\"2\\\"\\n self.data[i].convert_units(time_units, data_units)\\n self.len_units = len_units\\n self.time_units = time_units\\n # End Function\",\n \"def unit(self,unit_str,unit_scale):\\n self.units[unit_str] = unit_scale\\n return self\",\n \"def convert(obj, unit, axis):\\r\\n return obj\",\n \"def _get_unit_factor(cls, unit):\\n try:\\n if isinstance(unit, str):\\n unit = cls.UNIT_FACTOR_NAMES[unit]\\n return cls.UNIT_FACTORS[unit]\\n except KeyError:\\n raise UnsupportedUnitError()\",\n \"def fix_coord_units(cat, RA, DEC):\\n cat[RA].info.unit = u.deg\\n cat[DEC].info.unit = u.deg\\n return cat\",\n \"def to_units(self, amount):\\n return int(amount / self.price)\",\n \"def resolve_units(obj, _):\\n return obj.units.decode()\",\n \"def preprocess_sub_units(self):\\n if self.unit == \\\"char\\\":\\n self.preprocess_char()\\n elif self.unit == \\\"char-ngram\\\":\\n self.preprocess_char_ngram()\\n elif self.unit == \\\"morpheme\\\":\\n self.preprocess_morpheme()\\n elif self.unit == \\\"oracle\\\":\\n self.preprocess_oracle()\\n else:\\n sys.exit(\\\"Unknown unit\\\")\",\n \"def reduce_unit(self, guide_unit=None):\\n key = (self.unit, guide_unit)\\n if key in Quantity._reduce_cache:\\n (unit, value_factor) = Quantity._reduce_cache[key]\\n else:\\n value_factor = 1.0\\n canonical_units = {} # dict of dimensionTuple: (Base/ScaledUnit, exponent)\\n # Bias result toward guide units\\n if guide_unit != None:\\n for u, exponent in guide_unit.iter_base_or_scaled_units():\\n d = u.get_dimension_tuple()\\n if d not in canonical_units:\\n canonical_units[d] = [u, 0]\\n for u, exponent in self.unit.iter_base_or_scaled_units():\\n d = u.get_dimension_tuple()\\n # Take first unit found in a dimension as canonical\\n if d not in canonical_units:\\n canonical_units[d] = [u, exponent]\\n else:\\n value_factor *= (u.conversion_factor_to(canonical_units[d][0])**exponent)\\n canonical_units[d][1] += exponent\\n new_base_units = {}\\n for d in canonical_units:\\n u, exponent = canonical_units[d]\\n if exponent != 0:\\n assert u not in new_base_units\\n new_base_units[u] = exponent\\n # Create new unit\\n if len(new_base_units) == 0:\\n unit = dimensionless\\n else:\\n unit = Unit(new_base_units)\\n # There might be a factor due to unit conversion, even though unit is dimensionless\\n # e.g. suppose unit is meter/centimeter\\n if unit.is_dimensionless():\\n unit_factor = unit.conversion_factor_to(dimensionless)\\n if unit_factor != 1.0:\\n value_factor *= unit_factor\\n # print \\\"value_factor = %s\\\" % value_factor\\n unit = dimensionless\\n Quantity._reduce_cache[key] = (unit, value_factor)\\n # Create Quantity, then scale (in case value is a container)\\n # That's why we don't just scale the value.\\n result = Quantity(self._value, unit)\\n if value_factor != 1.0:\\n # __mul__ strips off dimensionless, if appropriate\\n result = result * value_factor\\n if unit.is_dimensionless():\\n assert unit is dimensionless # should have been set earlier in this method\\n if is_quantity(result):\\n result = result._value\\n return result\",\n \"def assign_unit(self):\\n self.units = {}\\n for unit in RADIAL_UNITS:\\n if unit.REPR == \\\"2th_deg\\\":\\n self.units[unit] = self.tth_deg\\n elif unit.REPR == \\\"2th_rad\\\":\\n self.units[unit] = self.tth_rad\\n elif unit.REPR == \\\"q_nm^-1\\\":\\n self.units[unit] = self.q_nm\\n elif unit.REPR == \\\"q_A^-1\\\":\\n self.units[unit] = self.q_A\\n elif unit.REPR == \\\"r_mm\\\":\\n self.units[unit] = self.r_mm\\n else:\\n logger.warning(\\\"Unit unknown to GUI %s\\\" % unit)\",\n \"def add_special_conversion(self, from_units, to_units, converter):\\n self.special_conversions[(from_units, to_units)] = converter\",\n \"def set_distance_units(value=np.NaN, from_units='mm', to_units='cm'):\\n if from_units == to_units:\\n return value\\n\\n coeff = 1\\n if from_units == 'cm':\\n if to_units == 'mm':\\n coeff = 10\\n elif to_units == 'm':\\n coeff = 0.01\\n else:\\n raise ValueError(\\\"to_units not supported ['cm','m','mm']!\\\")\\n elif from_units == 'mm':\\n if to_units == 'cm':\\n coeff = 0.1\\n elif to_units == 'm':\\n coeff = 0.001\\n else:\\n raise ValueError(\\\"to_units not supported ['cm','m','mm']!\\\")\\n elif from_units == 'm':\\n if to_units == 'mm':\\n coeff = 1000\\n elif to_units == 'cm':\\n coeff = 100\\n else:\\n raise ValueError(\\\"to_units not supported ['cm','m','mm']!\\\")\\n else:\\n raise ValueError(\\\"to_units not supported ['cm','m','mm']!\\\")\\n\\n return coeff * value\",\n \"def to_base_unit(val: float, unit: str = \\\"\\\") -> float:\\n unit_scalar = UNITS.get(unit, None)\\n if not unit_scalar:\\n raise UnknownUnitError(f\\\"Unit '{unit}' is not supported\\\")\\n\\n return val * unit_scalar\",\n \"def update_units(self):\\n unit_var_value = self.view.vars['unit'].get()\\n if unit_var_value == 'm3ph':\\n self.minran_u_label.config(text='m³/h')\\n self.maxran_u_label.config(text='m³/h')\\n self.points_tview.heading('vflow', text='Przepływ [m³/h]', anchor=tk.CENTER)\\n elif unit_var_value == 'lps':\\n self.minran_u_label.config(text='l/s')\\n self.maxran_u_label.config(text='l/s')\\n self.points_tview.heading('vflow', text='Przepływ [l/s]', anchor=tk.CENTER)\\n self.view.vars['pump_eff_min'].convert_unit(unit_var_value)\\n self.view.vars['pump_eff_max'].convert_unit(unit_var_value)\\n self.view.vars['pump_characteristic'].convert_unit(unit_var_value)\",\n \"def unit_string(value, units, prefu={'M', 'L', 'J', 'C', 'V', 'N', 'W', 'Pa'}):\\r\\n if units == unity or not value:\\r\\n return value, \\\"\\\", \\\"\\\"\\r\\n SIunits = list(units)\\r\\n derived = dict((pu, 0) for pu in prefu if sum(abs(t) for t in unitquant[pu].units) > 1)\\r\\n while derived:\\r\\n (improvement, d, sign) = try_all_derived(SIunits, derived)\\r\\n if improvement <= 0:\\r\\n break\\r\\n derived[d] += sign\\r\\n for i, used_in_derived in enumerate(unitquant[d].units):\\r\\n SIunits[i] -= used_in_derived * sign\\r\\n value /= unitquant[d].number ** sign\\r\\n allunits = dict([(x, derived[x]) for x in derived if derived[x]])\\r\\n DUS = [du for du in allunits if du in derived]\\r\\n for DU in DUS: # choose between atm and mmHg etc.\\r\\n choices = [pu for pu in derived if unitquant[pu].units == unitquant[DU].units]\\r\\n if not choices:\\r\\n break\\r\\n quality = [(abs(math_log10(abs(value) / (unitquant[c].number / unitquant[DU].number) ** allunits[DU]) - 1.0), c)\\r\\n for c in choices]\\r\\n best = min(quality)[1]\\r\\n if best != DU:\\r\\n allunits[best] = allunits[DU]\\r\\n value /= (unitquant[best].number / unitquant[DU].number) ** allunits[best]\\r\\n allunits[DU] = 0\\r\\n for i, SIU in enumerate(SIunit_symbols): # choose between m, cm, mm etc.\\r\\n if not SIunits[i]:\\r\\n continue\\r\\n choices = [pu for pu in prefu if (pu not in derived) and unitquant[pu].units[i]]\\r\\n if not choices:\\r\\n break\\r\\n quality = [(abs(math_log10(abs(value) / unitquant[c].number ** (SIunits[i] / unitquant[c].units[i])) - 1.0), c)\\r\\n for c in choices]\\r\\n best = min(quality)[1]\\r\\n allunits[best] = Fraction(SIunits[i], unitquant[best].units[i])\\r\\n if allunits[best].denominator == 1:\\r\\n allunits[best] = int(allunits[best])\\r\\n SIunits[i] = 0\\r\\n value /= unitquant[best].number ** allunits[best]\\r\\n for u, d in zip(SIunit_symbols, SIunits):\\r\\n if d:\\r\\n allunits[u] = d\\r\\n poslist = [(u, exp) for u, exp in allunits.items() if exp > 0]\\r\\n neglist = [(u, -exp) for u, exp in allunits.items() if exp < 0]\\r\\n return value, poslist, neglist\",\n \"def SBMLUnitsConverter_init():\\n return _libsbml.SBMLUnitsConverter_init()\",\n \"def infer_original_units(self, dimensions):\\n dimensions = units.Unit(dimensions)\\n d = dimensions.dimensional_project(\\n self._file_units_system + [\\\"a\\\", \\\"h\\\"])\\n new_unit = reduce(lambda x, y: x * y, [\\n a ** b for a, b in zip(self._file_units_system, d)])\\n return new_unit\",\n \"def convert_mass(self, event):\\n try:\\n #Compare other unit to one unit(kilograms)\\n current_value, current_unit = float(\\\"0\\\" + str(self.v.get())), self.dropdown.get()\\n unit_comp = {\\\"Earth masses\\\": 5.97219e+24, \\\"Solar masses\\\": 1.9890000000000002e+30, \\\"carats\\\": 0.0002, \\\"cental\\\": 45.359237, \\\"decagrams\\\": 0.01, \\\"femtograms\\\": 1e-18, \\\"grains\\\": 6.479891000000001e-05, \\\"grams\\\": 0.001, \\\"hectograms\\\": 0.1, \\\"hundredweights\\\": 50.802345, \\\"kilograms\\\": 1.0, \\\"kilotonnes\\\": 1000000.0, \\\"megatonnes\\\": 1000000000.0, \\\"micrograms\\\": 1e-09, \\\"milligrams\\\": 1e-06, \\\"nanograms\\\": 1e-12, \\\"ounces(US & UK)\\\": 0.02835, \\\"ounces(precious metals)\\\": 0.031103, \\\"picograms\\\": 1e-15, \\\"pounds(US & UK)\\\": 0.453592, \\\"pounds(precious metals)\\\": 0.373242, \\\"slugs\\\": 14.593903, \\\"stones\\\": 6.350293, \\\"tonnes(metric)\\\": 1000.0, \\\"tons(UK)\\\": 1016.046909, \\\"tons(US)\\\": 907.18474}\\n value_comp, printer = current_value * unit_comp[current_unit], \\\"\\\"\\n unit_list = sorted(unit_comp.keys())\\n unit_list.remove(current_unit)\\n for unit in unit_list:\\n printer += \\\"To %s \\\" % unit + \\\" \\\" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\\\"\\\", \\\"\\\\n\\\"][unit_list[-1] != unit]\\n except ValueError: #In case user enter the other type of value, not Int or Float\\n printer = \\\"Value is invalid.\\\"\\n self.print_text(printer)\",\n \"def convert_units(data, hdr, conv_to = \\\"surf_br\\\"):\\n \\n data_unit = hdr[\\\"SIGUNIT\\\"]\\n \\n if \\\"Jy/pix\\\" in data_unit:\\n # pixel size in rad\\n px_x = abs(hdr[\\\"CDELT1\\\"])*2*np.pi/360\\n px_y = abs(hdr[\\\"CDELT2\\\"])*2*np.pi/360\\n \\n #pixel size in arcsec\\n \\n px_x = abs(hdr[\\\"CDELT1\\\"])*3600\\n px_y = abs(hdr[\\\"CDELT2\\\"])*3600\\n conversion_factor = 1000/(px_x*px_y)\\n \\n unit_label = \\\"mJy/arcsec^2\\\"\\n \\n #in case we want to convert to units flux, we need to multiply by the size (in steradians) of a pixel.\\n if conv_to == \\\"flux\\\":\\n conversion_factor*=abs(hdr[\\\"CDELT1\\\"])*abs(hdr[\\\"CDELT2\\\"])*(2*np.pi/360)**2\\n unit_label = \\\"mJy\\\"\\n \\n data *= conversion_factor\\n hdr[\\\"SIGUNIT\\\"] = unit_label\\n else:\\n print(\\\"\\\\t[WARNING]\\\\t \\\"+data_unit+\\\" conversion not yet implemented. No conversion performed.\\\")\\n \\n return data, hdr\",\n \"def units_to_pixels(self,units_):\\n if type(units_) == str and units_.lower() in [\\\"fwhm\\\",\\\"psf\\\"]:\\n units_ = self.fwhm\\n\\n return super(Image, self).units_to_pixels(units_, target=self.target)\",\n \"def convert_same_units(self):\\n # Convert pumping rate data\\n pump_units = \\\"%s3/%s\\\" % (self.len_units, self.time_units)\\n flag = _units.validate_units(pump_units)\\n if flag == 2:\\n self.pumprate.convert_units(self.time_units, pump_units)\\n self.pump_units = pump_units\",\n \"def test_change_units(self):\\n s = State(\\\"water\\\", T=Q_(100, \\\"degC\\\"), p=Q_(1.0, \\\"atm\\\"), units=\\\"EE\\\")\\n assert s.units == \\\"EE\\\"\\n s.units = \\\"SI\\\"\\n assert s.units == \\\"SI\\\"\\n assert s.cv.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.cp.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.s.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.h.units == \\\"kilojoule / kilogram\\\"\\n assert s.T.units == \\\"degree_Celsius\\\"\\n assert s.u.units == \\\"kilojoule / kilogram\\\"\\n assert s.v.units == \\\"meter ** 3 / kilogram\\\"\\n assert s.p.units == \\\"bar\\\"\",\n \"def __convert_to_mm(self, value, in_devunit=True):\\r\\n if in_devunit:\\r\\n value /= self.DEVUNIT_RATIO\\r\\n return value\",\n \"def units(inventory):\\n return inventory.reduce(convert.get_units)\",\n \"def native_unit_of_measurement(self) -> str:\\n return f\\\"{CURRENCY_CENT}/{UnitOfVolume.LITERS}\\\"\",\n \"def normalize(self, factor):\",\n \"def convert(value, unit, axis):\\n converted_value = value\\n if isinstance(unit, str) or isinstance(unit, Unit):\\n unit = (unit,)\\n if isinstance(value, (unyt_array, unyt_quantity)):\\n converted_value = value.to(*unit)\\n else:\\n value_type = type(value)\\n converted_value = []\\n for obj in value:\\n converted_value.append(obj.to(*unit))\\n converted_value = value_type(converted_value)\\n return converted_value\",\n \"def convert_units(array, in_units=\\\"None\\\"):\\n if in_units == \\\"None\\\" or in_units is None:\\n return array\\n else:\\n raise Exception(\\\"Unsupported unit for bispectrum descriptors.\\\")\",\n \"def units(self):\\n pass\",\n \"def convert_path_units(self, path_to_conv):\\n\\n converted_path = copy.deepcopy(path_to_conv) # TODO: figure out if this is the right way to do this- I have not yet understood how data should be handled here\\n\\n for i, coord in enumerate(converted_path):\\n converted_path[i][0] = coord[0] / self.units_in_meter\\n converted_path[i][1] = coord[1] / self.units_in_meter\\n converted_path[i][2] = coord[2] / self.units_in_meter\\n\\n return converted_path\",\n \"def to_axis_units(self, label, vals):\\n if label in ['Hmolar', 'Smolar', 'Umolar', 'Dmolar', 'P']:\\n return vals / 1000\\n elif label in ['T']:\\n return vals\\n else:\\n raise ValueError(label)\",\n \"def _override_units_system(self):\\n try:\\n f = open(self.filename+\\\".units\\\")\\n except OSError:\\n return\\n\\n name_mapping = {'pos': 'distance', 'vel': 'velocity'}\\n units_dict = {}\\n\\n for line in f:\\n if (not line.startswith(\\\"#\\\")):\\n if \\\":\\\" not in line:\\n raise OSError(\\\"Unknown format for units file %r\\\"%(self.filename+\\\".units\\\"))\\n else:\\n t, u = list(map(str.strip,line.split(\\\":\\\")))\\n t = name_mapping.get(t,t)\\n units_dict[t] = u\\n\\n self.set_units_system(**units_dict)\",\n \"def calc_unit_factor(self, ui_unit):\\n # namedView = self.document.getroot().find(inkex.addNS('namedview', 'sodipodi'))\\n # doc_units = self.getunittouu(str(1.0) + namedView.get(inkex.addNS('document-units', 'inkscape')))\\n unit_factor = self.getunittouu(str(1.0) + ui_unit)\\n return unit_factor\",\n \"def convert_units(data, typec,fromm, to):\\n cdata = []\\n \\n if typec == 'OPC_temporal':\\n cdata = OPCtimetransform(data, to)\\n elif typec == 'temporal':\\n if isinstance(data[0], float):\\n data = [str(i) for i in data]\\n cdata = tt.convertTime(data, fromm, to)\\n elif typec == 'units':\\n for measure in data:\\n cdata.append(conversion(measure, fromm, to))\\n else:\\n raise TypeError('Unknown or unsupported conversion tyoe: ' + typec)\\n cdata = data\\n \\n return cdata\",\n \"def convert(self, value, unit, axis):\\n scaled = getattr(value, self.scale)\\n if self.format in YMDHMS_FORMATS:\\n return scaled.mjd\\n elif self.format == \\\"byear_str\\\":\\n return scaled.byear\\n elif self.format == \\\"jyear_str\\\":\\n return scaled.jyear\\n else:\\n return getattr(scaled, self.format)\",\n \"def dim_unit_scaling(in_unit, out_unit):\\n\\n unit_vals = {\\n 'nm': 1e-9,\\n 'um': 1e-6,\\n 'mm': 1e-3,\\n 'cm': 1e-2,\\n 'm': 1.0,\\n 'km': 1e3,\\n }\\n\\n if in_unit not in unit_vals:\\n raise ValueError(\\n 'Invalid input unit {}. Must be one of {}'.format(\\n in_unit, list(unit_vals.keys())\\n )\\n )\\n if out_unit not in unit_vals:\\n raise ValueError(\\n 'Invalid input unit {}. Must be one of {}'.format(\\n in_unit, list(unit_vals.keys())\\n )\\n )\\n\\n return unit_vals[in_unit]/unit_vals[out_unit]\",\n \"def parseUnits(value, units):\\n\\tn = len(value)\\n\\tfor i, c in enumerate(value):\\n\\t\\tif c.isalpha():\\n\\t\\t\\tn = i\\n\\t\\t\\tbreak\\n\\n\\tnumberStr = value[:n]\\n\\tnumber = float(numberStr)\\n\\n\\tunitStr = value[n:]\\n\\tfor unit, multiplier in units:\\n\\t\\tif unitStr == unit:\\n\\t\\t\\treturn int(multiplier * number)\\n\\n\\traise ValueError('Unknown unit \\\"%s\\\"' % unitStr)\",\n \"def convert_temp(orig_temp, units):\\n switcher = {\\n 'k': ((orig_temp - 32) * 5.0 / 9.0) + 273.15,\\n 'c': (orig_temp - 32) * 5.0 / 9.0,\\n 'f': orig_temp\\n }\\n temperature = switcher.get(units.lower())\\n conversion = dict(original=orig_temp, units=units, temperature=temperature)\\n return conversion\",\n \"def original_units(self):\\n self.physical_units(distance=self.infer_original_units('km'),\\n velocity=self.infer_original_units('km s^-1'),\\n mass=self.infer_original_units('Msol'), persistent=False)\",\n \"def units(self, units):\\n\\n self._units = units\",\n \"def units(self, units):\\n\\n self._units = units\",\n \"def units(self, units):\\n\\n self._units = units\",\n \"def to_meters(d, d_unit):\\n if d_unit == UOM_M:\\n dm = d\\n elif d_unit == UOM_KM:\\n dm = d * 1000\\n elif d_unit == UOM_FEET:\\n dm = feet2m(d)\\n elif d_unit == UOM_SM:\\n dm = SM2m(d)\\n elif d_unit == UOM_NM:\\n dm = NM2m(d)\\n return dm\",\n \"def _get_units(self, q) -> unyt.Unit:\\n try:\\n units = q.units\\n except AttributeError:\\n units = unyt.dimensionless\\n return unyt.Unit(units, registry=self.registry)\",\n \"def units(self, key):\\n \\n # Strip any operators\\n _, key = get_operator(key)\\n \\n # Fill out aliases \\n if key in component_from_alias:\\n key = component_from_alias[key]\\n elif key == 'E':\\n key = 'electricField'\\n elif key == 'B':\\n key = 'magneticField' \\n \\n return pg_units(key)\",\n \"def _add_converted_units(self, dataframe, parameter, key='VALUE'):\\n convert_unit = self.parameters.get_converter(parameter)\\n try:\\n dataframe[key] = dataframe['DATA_VALUE'].apply(convert_unit)\\n except KeyError:\\n log.warn(\\\"Missing 'VALUE': no unit conversion.\\\")\\n else:\\n dataframe.unit = self.parameters.unit(parameter)\",\n \"def convert_volume(self, event):\\n try:\\n #Compare other unit to one unit(cubic decimeters)\\n current_value, current_unit = float(\\\"0\\\" + str(self.v.get())), self.dropdown.get()\\n unit_comp = {\\\"acre foot\\\": 1233481.837548, \\\"barrels\\\": 158.987295, \\\"bushels(UK)\\\": 36.36872, \\\"bushels(US)\\\": 35.23907, \\\"centiliters\\\": 0.01, \\\"cubic centimeters\\\": 0.001, \\\"cubic decameters\\\": 1000000.0, \\\"cubic decimeters\\\": 1.0, \\\"cubic feet\\\": 28.316847, \\\"cubic inches\\\": 0.016387, \\\"cubic kilometers\\\": 1000000000000.0, \\\"cubic meters\\\": 1000.0, \\\"cubic mile\\\": 4168181825000.0, \\\"cubic millimeters\\\": 1e-06, \\\"cubic yards\\\": 764.554858, \\\"cups\\\": 0.236588, \\\"deciliters\\\": 0.1, \\\"dram\\\": 0.003697, \\\"dram(imperial)\\\": 0.003552, \\\"fluid ounces(US)\\\": 0.029574, \\\"fluid ounces(imperial)\\\": 0.028413, \\\"gallons(US,dry)\\\": 4.404884, \\\"gallons(US,liquid)\\\": 3.785412, \\\"gallons(imperial)\\\": 4.54609, \\\"gill(US)\\\": 0.118294, \\\"gill(imperial)\\\": 0.142065, \\\"liters\\\": 1.0, \\\"liters(1901-1964)\\\": 1.000028, \\\"microliters\\\": 1e-06, \\\"milliliters\\\": 0.001, \\\"nanoliters\\\": 1e-09, \\\"picoliters\\\": 1e-12, \\\"pints(US,dry)\\\": 0.55061, \\\"pints(US,liquid)\\\": 0.473176, \\\"pints(imperial)\\\": 0.568261, \\\"quarts(UK,dry)\\\": 1.101221, \\\"quarts(US,liquid)\\\": 0.946353, \\\"quarts(imperial)\\\": 1.136523, \\\"table spoons\\\": 0.014787, \\\"tea spoons\\\": 0.004929}\\n value_comp, printer = current_value * unit_comp[current_unit], \\\"\\\"\\n unit_list = sorted(unit_comp.keys())\\n unit_list.remove(current_unit)\\n for unit in unit_list:\\n printer += \\\"To %s \\\" % unit + \\\" \\\" * (max([len(i) for i in unit_list]) - len(unit)) + str(value_comp / unit_comp[unit]) + [\\\"\\\", \\\"\\\\n\\\"][unit_list[-1] != unit]\\n except ValueError: #In case user enter the other type of value, not Int or Float\\n printer = \\\"Value is invalid.\\\"\\n self.print_text(printer)\",\n \"def FormatUnits(value, baseTwo=False, baseUnit=''):\\n\\n prefixes = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']\\n divisor = 1000\\n if baseTwo:\\n divisor = 1024\\n\\n for prefix in prefixes:\\n if value < divisor:\\n return \\\"{:.3f} {}{}\\\".format(value, prefix, baseUnit)\\n value = value / divisor\\n\\n return \\\"{:.3f}Y{}\\\".format(value, prefix, baseUnit)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7592755","0.7377087","0.7234802","0.72110605","0.7108356","0.71072423","0.70839715","0.6940497","0.6894842","0.68894947","0.6876686","0.68304235","0.6814569","0.67865115","0.67414594","0.67141014","0.6706773","0.66971725","0.6690622","0.6680311","0.6671551","0.6595691","0.6578424","0.65668213","0.65316856","0.65308386","0.65136975","0.65021867","0.64901304","0.6489734","0.64890987","0.6488808","0.6478774","0.64671737","0.6463886","0.6458047","0.6443598","0.6436676","0.64312726","0.63994974","0.6397012","0.63966924","0.6392289","0.63608336","0.63554114","0.6348171","0.63282067","0.6322117","0.63203406","0.63158053","0.6312976","0.63009185","0.62909234","0.6280629","0.62644833","0.6263192","0.6242805","0.62399966","0.6237339","0.6214608","0.621317","0.621072","0.6200366","0.6200238","0.61736536","0.61611664","0.6145289","0.61452866","0.6137428","0.6137146","0.61213803","0.6121287","0.6111201","0.6103776","0.6098507","0.60932314","0.6091527","0.6085691","0.6080469","0.60798085","0.60713017","0.60678303","0.60426885","0.6041562","0.60180664","0.59955704","0.5995","0.59943295","0.5989086","0.5988335","0.59722215","0.5967829","0.5967829","0.5967829","0.5933976","0.5926169","0.591727","0.5915237","0.5913493","0.59098727"],"string":"[\n \"0.7592755\",\n \"0.7377087\",\n \"0.7234802\",\n \"0.72110605\",\n \"0.7108356\",\n \"0.71072423\",\n \"0.70839715\",\n \"0.6940497\",\n \"0.6894842\",\n \"0.68894947\",\n \"0.6876686\",\n \"0.68304235\",\n \"0.6814569\",\n \"0.67865115\",\n \"0.67414594\",\n \"0.67141014\",\n \"0.6706773\",\n \"0.66971725\",\n \"0.6690622\",\n \"0.6680311\",\n \"0.6671551\",\n \"0.6595691\",\n \"0.6578424\",\n \"0.65668213\",\n \"0.65316856\",\n \"0.65308386\",\n \"0.65136975\",\n \"0.65021867\",\n \"0.64901304\",\n \"0.6489734\",\n \"0.64890987\",\n \"0.6488808\",\n \"0.6478774\",\n \"0.64671737\",\n \"0.6463886\",\n \"0.6458047\",\n \"0.6443598\",\n \"0.6436676\",\n \"0.64312726\",\n \"0.63994974\",\n \"0.6397012\",\n \"0.63966924\",\n \"0.6392289\",\n \"0.63608336\",\n \"0.63554114\",\n \"0.6348171\",\n \"0.63282067\",\n \"0.6322117\",\n \"0.63203406\",\n \"0.63158053\",\n \"0.6312976\",\n \"0.63009185\",\n \"0.62909234\",\n \"0.6280629\",\n \"0.62644833\",\n \"0.6263192\",\n \"0.6242805\",\n \"0.62399966\",\n \"0.6237339\",\n \"0.6214608\",\n \"0.621317\",\n \"0.621072\",\n \"0.6200366\",\n \"0.6200238\",\n \"0.61736536\",\n \"0.61611664\",\n \"0.6145289\",\n \"0.61452866\",\n \"0.6137428\",\n \"0.6137146\",\n \"0.61213803\",\n \"0.6121287\",\n \"0.6111201\",\n \"0.6103776\",\n \"0.6098507\",\n \"0.60932314\",\n \"0.6091527\",\n \"0.6085691\",\n \"0.6080469\",\n \"0.60798085\",\n \"0.60713017\",\n \"0.60678303\",\n \"0.60426885\",\n \"0.6041562\",\n \"0.60180664\",\n \"0.59955704\",\n \"0.5995\",\n \"0.59943295\",\n \"0.5989086\",\n \"0.5988335\",\n \"0.59722215\",\n \"0.5967829\",\n \"0.5967829\",\n \"0.5967829\",\n \"0.5933976\",\n \"0.5926169\",\n \"0.591727\",\n \"0.5915237\",\n \"0.5913493\",\n \"0.59098727\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72322226"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":14873,"cells":{"query":{"kind":"string","value":"Convert this object into a dictionary."},"document":{"kind":"string","value":"def to_dict(self) -> dict:\n return dict(sentences=[sentence.to_dict() for sentence in self.sentences])"},"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 as_dict(self):\n return asdict(self)","def to_obj(self):\n return dict()","def to_dict(self):\n return to_dict(self.__dict__)","def asdict(self) -> dict:\n return self.__asdict(self)","def to_dict(self):\n return dict(self)","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def _to_dict(self):\n return self.to_dict()","def dict(self):\n return objToDict(self)","def to_dict(self):\n raise NotImplementedError('To be implemented in subclass.')","def _as_dict(self):\n return dict(self.items())","def to_dict(self):\r\n return self.__dict__","def to_dict(self) -> dict:","def to_dict(self) -> Dict[str, Any]:\n return self.__dict__.copy()","def to_dict(self) -> dict:\n return self.__dict__.copy()","def to_dict(self):\n data = {}\n for key, value in self.__dict__.items():\n try:\n data[key] = value.to_dict()\n except AttributeError:\n data[key] = value\n return data","def to_dict(self):\n return dict(self.__data)","def to_dict(self) -> Dict[str, Any]:\n data = asdict(self)\n\n data = self._to_dict_transform(data)\n\n return data","def as_dict(self):\n return dict(self.as_OD())","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self) -> Dict:\n return {'object_id': self.object_id, 'data_id': self.data_id}","def as_dict(self):\n return dict(self.items())","def to_dict(self):\r\n raise NotImplementedError","def to_dict(self):\n pass","def to_dict(self):\n\n # Return dict\n return self.dict","def _to_dict(self) -> dict:\n pass","def to_dict(self):\n raise NotImplementedError","def as_dict(self):\n return self.__dict__","def as_dict(self):\n return dict(self._d)","def to_dict(self):\n\t\toutput = copy.deepcopy(self.__dict__)\n\t\treturn output","def to_dict(self) -> dict:\n return dataclasses.asdict(self)","def to_dict(self):\n return self._dict","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self):\r\n output = copy.deepcopy(self.__dict__)\r\n return output","def to_dict(self) -> Dict:\n _dict = {}\n if hasattr(self, 'name') and self.name is not None:\n _dict['name'] = self.name\n if hasattr(self, 'value') and self.value is not None:\n _dict['value'] = self.value\n return _dict","def to_dict(self) -> Dict:\n _dict = {}\n if hasattr(self, 'name') and self.name is not None:\n _dict['name'] = self.name\n if hasattr(self, 'value') and self.value is not None:\n _dict['value'] = self.value\n return _dict","def convert_to_dict(self):\n # Populate the dictionary with object meta data\n obj_dict = {\"__class__\": self.__class__.__name__, \"__module__\": self.__module__}\n # Populate the dictionary with object properties\n obj_dict.update(self.__dict__)\n if self.n_to is not None:\n obj_dict['n_to'] = self.n_to\n if self.s_to is not None:\n obj_dict['s_to'] = self.s_to\n if self.e_to is not None:\n obj_dict['e_to'] = self.e_to\n if self.w_to is not None:\n obj_dict['w_to'] = self.w_to\n if self.u_to is not None:\n obj_dict['u_to'] = self.u_to\n if self.d_to is not None:\n obj_dict['d_to'] = self.d_to\n return obj_dict","def to_dict(self):\n return {}","def to_dict(self):","def to_dict(self):\n output = copy.deepcopy(self.__dict__)\n return output","def to_dict(self):\n output = copy.deepcopy(self.__dict__)\n return output","def to_dict(self):\n output = copy.deepcopy(self.__dict__)\n return output","def to_dict(self):\n output = copy.deepcopy(self.__dict__)\n return output","def to_dict(self):\n output = copy.deepcopy(self.__dict__)\n return output","def to_dict(self):\n output = copy.deepcopy(self.__dict__)\n return output","def to_dict(self):\n output = copy.deepcopy(self.__dict__)\n return output"],"string":"[\n \"def as_dict(self):\\n return asdict(self)\",\n \"def to_obj(self):\\n return dict()\",\n \"def to_dict(self):\\n return to_dict(self.__dict__)\",\n \"def asdict(self) -> dict:\\n return self.__asdict(self)\",\n \"def to_dict(self):\\n return dict(self)\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def _to_dict(self):\\n return self.to_dict()\",\n \"def dict(self):\\n return objToDict(self)\",\n \"def to_dict(self):\\n raise NotImplementedError('To be implemented in subclass.')\",\n \"def _as_dict(self):\\n return dict(self.items())\",\n \"def to_dict(self):\\r\\n return self.__dict__\",\n \"def to_dict(self) -> dict:\",\n \"def to_dict(self) -> Dict[str, Any]:\\n return self.__dict__.copy()\",\n \"def to_dict(self) -> dict:\\n return self.__dict__.copy()\",\n \"def to_dict(self):\\n data = {}\\n for key, value in self.__dict__.items():\\n try:\\n data[key] = value.to_dict()\\n except AttributeError:\\n data[key] = value\\n return data\",\n \"def to_dict(self):\\n return dict(self.__data)\",\n \"def to_dict(self) -> Dict[str, Any]:\\n data = asdict(self)\\n\\n data = self._to_dict_transform(data)\\n\\n return data\",\n \"def as_dict(self):\\n return dict(self.as_OD())\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self) -> Dict:\\n return {'object_id': self.object_id, 'data_id': self.data_id}\",\n \"def as_dict(self):\\n return dict(self.items())\",\n \"def to_dict(self):\\r\\n raise NotImplementedError\",\n \"def to_dict(self):\\n pass\",\n \"def to_dict(self):\\n\\n # Return dict\\n return self.dict\",\n \"def _to_dict(self) -> dict:\\n pass\",\n \"def to_dict(self):\\n raise NotImplementedError\",\n \"def as_dict(self):\\n return self.__dict__\",\n \"def as_dict(self):\\n return dict(self._d)\",\n \"def to_dict(self):\\n\\t\\toutput = copy.deepcopy(self.__dict__)\\n\\t\\treturn output\",\n \"def to_dict(self) -> dict:\\n return dataclasses.asdict(self)\",\n \"def to_dict(self):\\n return self._dict\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self):\\r\\n output = copy.deepcopy(self.__dict__)\\r\\n return output\",\n \"def to_dict(self) -> Dict:\\n _dict = {}\\n if hasattr(self, 'name') and self.name is not None:\\n _dict['name'] = self.name\\n if hasattr(self, 'value') and self.value is not None:\\n _dict['value'] = self.value\\n return _dict\",\n \"def to_dict(self) -> Dict:\\n _dict = {}\\n if hasattr(self, 'name') and self.name is not None:\\n _dict['name'] = self.name\\n if hasattr(self, 'value') and self.value is not None:\\n _dict['value'] = self.value\\n return _dict\",\n \"def convert_to_dict(self):\\n # Populate the dictionary with object meta data\\n obj_dict = {\\\"__class__\\\": self.__class__.__name__, \\\"__module__\\\": self.__module__}\\n # Populate the dictionary with object properties\\n obj_dict.update(self.__dict__)\\n if self.n_to is not None:\\n obj_dict['n_to'] = self.n_to\\n if self.s_to is not None:\\n obj_dict['s_to'] = self.s_to\\n if self.e_to is not None:\\n obj_dict['e_to'] = self.e_to\\n if self.w_to is not None:\\n obj_dict['w_to'] = self.w_to\\n if self.u_to is not None:\\n obj_dict['u_to'] = self.u_to\\n if self.d_to is not None:\\n obj_dict['d_to'] = self.d_to\\n return obj_dict\",\n \"def to_dict(self):\\n return {}\",\n \"def to_dict(self):\",\n \"def to_dict(self):\\n output = copy.deepcopy(self.__dict__)\\n return output\",\n \"def to_dict(self):\\n output = copy.deepcopy(self.__dict__)\\n return output\",\n \"def to_dict(self):\\n output = copy.deepcopy(self.__dict__)\\n return output\",\n \"def to_dict(self):\\n output = copy.deepcopy(self.__dict__)\\n return output\",\n \"def to_dict(self):\\n output = copy.deepcopy(self.__dict__)\\n return output\",\n \"def to_dict(self):\\n output = copy.deepcopy(self.__dict__)\\n return output\",\n \"def to_dict(self):\\n output = copy.deepcopy(self.__dict__)\\n return output\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8573397","0.8572996","0.8508446","0.8472537","0.8470109","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.8465864","0.83861154","0.833088","0.8318425","0.8314154","0.8307656","0.82877374","0.8278299","0.8263981","0.8257067","0.82519394","0.8246964","0.821347","0.821347","0.821347","0.821347","0.821347","0.821347","0.8204667","0.8202273","0.8193933","0.818858","0.8183974","0.818169","0.81814766","0.8160288","0.8127622","0.8104282","0.8092828","0.80690026","0.80637515","0.80637515","0.80637515","0.80637515","0.80637515","0.80637515","0.80637515","0.80637515","0.80637515","0.80637515","0.8048745","0.8048745","0.80454415","0.80451953","0.79898685","0.7983624","0.7983624","0.7983624","0.7983624","0.7983624","0.7983624","0.7983624"],"string":"[\n \"0.8573397\",\n \"0.8572996\",\n \"0.8508446\",\n \"0.8472537\",\n \"0.8470109\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.8465864\",\n \"0.83861154\",\n \"0.833088\",\n \"0.8318425\",\n \"0.8314154\",\n \"0.8307656\",\n \"0.82877374\",\n \"0.8278299\",\n \"0.8263981\",\n \"0.8257067\",\n \"0.82519394\",\n \"0.8246964\",\n \"0.821347\",\n \"0.821347\",\n \"0.821347\",\n \"0.821347\",\n \"0.821347\",\n \"0.821347\",\n \"0.8204667\",\n \"0.8202273\",\n \"0.8193933\",\n \"0.818858\",\n \"0.8183974\",\n \"0.818169\",\n \"0.81814766\",\n \"0.8160288\",\n \"0.8127622\",\n \"0.8104282\",\n \"0.8092828\",\n \"0.80690026\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.80637515\",\n \"0.8048745\",\n \"0.8048745\",\n \"0.80454415\",\n \"0.80451953\",\n \"0.79898685\",\n \"0.7983624\",\n \"0.7983624\",\n \"0.7983624\",\n \"0.7983624\",\n \"0.7983624\",\n \"0.7983624\",\n \"0.7983624\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14874,"cells":{"query":{"kind":"string","value":"Convert this object into a string."},"document":{"kind":"string","value":"def to_string(self) -> str:\n return f\"<Document, #sentences: {len(self.sentences)}>\""},"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 to_string(self):\r\n return self.__str__()","def serialize(self):\n\n return str(self)","def serialize(self):\n\n\t\treturn str(self)","def __str__(self):\n return str(self.serialize())","def to_str(self) -> str:","def __str__(self):\n return bytes_to_str(bytes(self))","def to_string(self):\n return json.dumps(self.to_json(), cls=ObjectEncoder)","def __str__ (self) :\n\n return self.as_string()","def to_string(self) -> str:\n return json.dumps(self.to_json())","def to_string(self) -> str:\n return json.dumps(self.to_json())","def toString(self) -> str:\n raise NotImplementedError","def __str__(self):\n buf = StringIO()\n self.write_to(buf)\n return buf.getvalue()","def __str__(self):\n return bytes_to_string(self._bytes)","def __str__(self) -> str:\n return self.encode()","def ToString(self):\r\n pass","def ToString(self):\r\n pass","def __str__(self) -> str:\n return str(self.getvalue())","def __str__(self) -> str:\n return str(self.getvalue())","def __str__(self) -> str:\n return str(self.getvalue())","def __str__(self):\n return str(self.__data)","def __str__(self):\n return str(self.__dict__['_obj'])","def __str__(self):\n return str(self.obj)","def __str__(self):\n return str(self._data)","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())"],"string":"[\n \"def to_string(self):\\r\\n return self.__str__()\",\n \"def serialize(self):\\n\\n return str(self)\",\n \"def serialize(self):\\n\\n\\t\\treturn str(self)\",\n \"def __str__(self):\\n return str(self.serialize())\",\n \"def to_str(self) -> str:\",\n \"def __str__(self):\\n return bytes_to_str(bytes(self))\",\n \"def to_string(self):\\n return json.dumps(self.to_json(), cls=ObjectEncoder)\",\n \"def __str__ (self) :\\n\\n return self.as_string()\",\n \"def to_string(self) -> str:\\n return json.dumps(self.to_json())\",\n \"def to_string(self) -> str:\\n return json.dumps(self.to_json())\",\n \"def toString(self) -> str:\\n raise NotImplementedError\",\n \"def __str__(self):\\n buf = StringIO()\\n self.write_to(buf)\\n return buf.getvalue()\",\n \"def __str__(self):\\n return bytes_to_string(self._bytes)\",\n \"def __str__(self) -> str:\\n return self.encode()\",\n \"def ToString(self):\\r\\n pass\",\n \"def ToString(self):\\r\\n pass\",\n \"def __str__(self) -> str:\\n return str(self.getvalue())\",\n \"def __str__(self) -> str:\\n return str(self.getvalue())\",\n \"def __str__(self) -> str:\\n return str(self.getvalue())\",\n \"def __str__(self):\\n return str(self.__data)\",\n \"def __str__(self):\\n return str(self.__dict__['_obj'])\",\n \"def __str__(self):\\n return str(self.obj)\",\n \"def __str__(self):\\n return str(self._data)\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8671065","0.8303624","0.8287494","0.8237525","0.8199979","0.8178291","0.8064898","0.8064313","0.80085224","0.80085224","0.8003638","0.79904777","0.7987857","0.7974399","0.7922337","0.7922337","0.7921466","0.7921466","0.7921466","0.79149413","0.78538585","0.7830347","0.7828956","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061","0.7818061"],"string":"[\n \"0.8671065\",\n \"0.8303624\",\n \"0.8287494\",\n \"0.8237525\",\n \"0.8199979\",\n \"0.8178291\",\n \"0.8064898\",\n \"0.8064313\",\n \"0.80085224\",\n \"0.80085224\",\n \"0.8003638\",\n \"0.79904777\",\n \"0.7987857\",\n \"0.7974399\",\n \"0.7922337\",\n \"0.7922337\",\n \"0.7921466\",\n \"0.7921466\",\n \"0.7921466\",\n \"0.79149413\",\n \"0.78538585\",\n \"0.7830347\",\n \"0.7828956\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\",\n \"0.7818061\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14875,"cells":{"query":{"kind":"string","value":"insert a column to tb. if called, all operation related to db must be fitted."},"document":{"kind":"string","value":"def insert_column(self, tb_name, column_name, data_type):\n sentences = f\"\"\"\n ALTER TABLE {tb_name} ADD COLUMN {column_name} {data_type};\n \"\"\"\n print(sentences)\n self.commit(sentences)"},"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 _addColumn(self, table, column, init_data):\n\t\tcommand = \"ALTER TABLE \" + table + \" ADD COLUMN \" + str(column) + \" \" + getSQLiteType(init_data)\n\t\ttry:\n\t\t\tself._run_command(command)\n\t\texcept sqlite3.OperationalError:\n\t\t\tprint(\"Column \" + str(column) + \" already exists!\")","def insert_column(self):\n try:\n lbl_name = Tk.Label(self, text='Enter a column name: ')\n lbl_name.grid(row=0, column=0, sticky=Tk.W+Tk.E)\n ent_name = Tk.Entry(self)\n ent_name.grid(row=0, column=1, sticky=Tk.W+Tk.E)\n lbl_type = Tk.Label(self, text='Enter a column type: ')\n lbl_type.grid(row=1, column=0, sticky=Tk.W+Tk.E)\n ent_type = Tk.Entry(self)\n ent_type.grid(row=1, column=1, sticky=Tk.W+Tk.E)\n\n def _insert_column():\n c_name = ent_name.get()\n c_type = ent_type.get()\n self.parent.insert_column(self.parent.table, c_name, c_type)\n self.destroy()\n self.parent.populate_display()\n b_ins = Tk.Button(self,\n text='Insert Column',\n command=_insert_column)\\\n .grid(row=2, column=1, sticky=Tk.W+Tk.E)\n except Exception, ex:\n logging.error(ex)\n traceback.print_exc()","def add_column(self, tap_column):\r\n self.__columns.append(tap_column)","def add_column(self, fieldname, column, align=..., valign=...):\n ...","def insert_column(self, column_name, column_type, table, params=None, overwrite=False, after_col=None, verbose=True):\n \n assert(self.connected)\n \n try: assert(self.check_table(table, verbose=False)) \n except AssertionError: raise TableNotFoundError\n \n \n \n if self.check_column(column_name, table, verbose=False): \n \n if not overwrite:\n \n if verbose: print(\"The column '{0}' already exists in the table '{1}'.\".format(column_name, table))\n return False\n \n else:\n \n if verbose: \n print(\"The column '{0}' already exists in the table '{1}'.\".format(column_name, table))\n \n self.delete_column(column_name,table,verbose=True)\n \n self._insert_column(column_name, column_type, table, params, overwrite, after_col)\n \n else:\n \n self._insert_column(column_name, column_type, table, params, overwrite, after_col)\n \n \n if verbose: print(\"Column '{0}' added to the table '{1}' successfully.\".format(column_name, table))\n \n return True","def _insert_column(self, column_name, column_type, table, params=None, overwrite=False, after_col=None, verbose=True):\n \n not_null = ''\n auto_increment = ''\n \n if params != None and 'not_null' in params:\n not_null = 'NOT NULL'\n \n \n if params != None and 'auto_increment' in params:\n auto_increment = \"AUTO_INCREMENT\"\n \n \n ADD_COLUMN_COMMAND = \"ALTER TABLE {0} ADD {1} {2} {3} {4}\".format(table, column_name, column_type, not_null, auto_increment)\n \n if (after_col != None and type(after_col) is str):\n ADD_COLUMN_COMMAND += \" AFTER {0} \".format(after_col)\n \n \n self.cursor.execute(ADD_COLUMN_COMMAND)\n \n if verbose: \n print(\"Adding the column '{0}' to the table '{1}'...\".format(column_name, table))\n print(\"\\t\" + ADD_COLUMN_COMMAND) \n \n \n if params != None and 'foreign_key' in params:\n \n if 'references' not in params:\n raise InvalidParameterError\n \n referenced_table = params['references'].split('(')[0]\n referenced_column = params['references'].split('(')[1][:-1] \n \n \n if (not self.check_table(referenced_table, verbose=False)):\n raise(TableNotFoundError)\n \n \n if (not self.check_column(referenced_column, referenced_table, verbose=False)):\n raise(ColumnNotFoundError)\n \n \n ADD_FOREIGN_KEY_COMMAND = \"ALTER TABLE {0} ADD FOREIGN KEY ({1}) REFERENCES {2}({3})\".format(table, column_name, referenced_table, referenced_column)\n \n \n if verbose: \n print(\"\\t\" + ADD_FOREIGN_KEY_COMMAND) \n \n self.cursor.execute(ADD_FOREIGN_KEY_COMMAND)","def addColumn(self, *column):\n self.insertColumn(self._width, *column)","def add_column_into_source(self, tap_type, table, new_column):\n run_query_method = getattr(self, f'run_query_tap_{tap_type}')\n run_query_method(\n f'ALTER TABLE {table} ADD {new_column[\"name\"]} int'\n )\n run_query_method(\n f'UPDATE {table} set {new_column[\"name\"]}={new_column[\"value\"]} where 1=1'\n )","def create_column(self, new_column, dtype):\n self.logger.debug(\"[%u] Ready to add column %s\" %\n (os.getpid(), new_column))\n ddl = \"\"\"\n ALTER TABLE {schema}.{table}\n ADD COLUMN IF NOT EXISTS {col} {type}\n \"\"\"\n # TODO Replace by execute_ddl func and test it\n with get_sink_connection_string(self) as conn:\n with conn.cursor() as cursor:\n cursor.execute(ddl.format(schema=self.config['schema'],\n table=self.config['table'],\n col=new_column,\n type=dtype))\n self.logger.debug(\"[%u] Column %s has been added\" %\n (os.getpid(), new_column))","def AddColumn(self, column):\n self.columns.append(column)\n self.column_dict[column.column_id] = column","def insertColumn(self, index, *column):\n if ((len(column) == 1) and (type(column[0]) in MATRIX_VALID_COLLECTIONS)):\n column = column[0]\n if self._height:\n if not (len(column) == self._height):\n raise ValueError('Improper length for new column: %d, should be %d' % (len(column), self._height))\n else:\n self._height = len(column)\n for i in range(self._height):\n self._value.append(list())\n self._width += 1\n for i in range(self._height):\n if not (type(column[i]) in MATRIX_VALID_TYPES):\n message = \"Values must be of type \"\n for t in range(len(MATRIX_VALID_TYPENAMES)):\n if t:\n message += ' or '\n message += \"'%s'\" % MATRIX_VALID_TYPENAMES[t]\n raise TypeError(message)\n self._value[i].insert(index, column[i])","def insert_column(self, identifier, position, name, datastore):\n # Raise ValueError if given colum name is invalid.\n if name is not None and not is_valid_name(name):\n raise ValueError(\"invalid column name '{}'\".format(name))\n # Get dataset. Raise exception if dataset is unknown.\n dataset = datastore.get_dataset(identifier)\n if dataset is None:\n raise ValueError(\"unknown dataset '{}'\".format(identifier))\n # Insert new column into dataset.\n df = dataset.to_dataframe()\n df = vizual.insert_column(df=df, names=[name], pos=position)\n # Store updated dataset to get new identifier.\n ds = datastore.update_dataset(\n origin=dataset,\n df=df,\n annotations=dataset.annotations\n )\n return VizualApiResult(ds)","def addcolumn(self, colname, coldata):\n if len(coldata) != len(self):\n raise ValueError,\"Column length must match catalog length\"\n\n #Most of the bookkeeping is the same as for an empty column\n self.addemptycolumn(colname,coldata.dtype)\n\n #and then we reset the column to contain the actual data\n setattr(self,colname,coldata)","def add_column(self, table_name: str, column) -> None:\n sql = 'ALTER TABLE ' + table_name + ' ADD COLUMN ' + column.to_sql()\n self.cursor.execute(sql)","def setCol(self, col):\n self.column = col","def addTableColumn(self, tablename, columnname, columntype):\n\n # Check if the table exists\n if tablename in self.getTableNames():\n\n # Check that the column does not already exist\n if columnname not in self.getColumnNames(tablename):\n\n #Allow columnames with spaces\n columnname = '`'+columnname+'`'\n\n \"\"\"# Fit characters to the allowed format if necessary\n fmt = ''\n if (self.connector == 'mysql' and\n ('TEXT' in columntype or 'VARCHAR' in columntype) and\n not ('CHARACTER SET' in columntype or\n 'utf8mb4' in columntype)):\n\n # We enforze utf8mb4 for mysql\n fmt = ' CHARACTER SET utf8mb4'\n\n\n sqlcmd = ('ALTER TABLE ' + tablename + ' ADD COLUMN ' +\n columnname + ' ' + columntype + fmt)\"\"\"\n sqlcmd = ('ALTER TABLE ' + tablename + ' ADD COLUMN ' +\n columnname + ' ' + columntype) \n self._c.execute(sqlcmd)\n\n # Commit changes\n self._conn.commit()\n\n else:\n print((\"WARNING: Column {0} already exists in table {1}.\"\n ).format(columnname, tablename))\n\n else:\n print('Error adding column to table. Please, select a valid ' +\n 'table name from the list')\n print(self.getTableNames())\n\n return","def insert_column(df, colTitle, colIndex, fillValue):\n if colTitle not in df.columns:\n df.insert(colIndex, colTitle, fillValue, True)\n return df","def add_column(self, col_name, definition):\n if not self.column_exists(col_name):\n self.execute(self.commands.add_column(self.name, col_name, definition))","def insert(self, j, column, default=None):\n try: column = [v for v in column]\n except:\n raise TypeError, \"Table.columns.insert(x): x must be list\"\n column = column + [default] * (len(self._table) - len(column))\n if len(column) > len(self._table):\n self._table.extend([[None]] * (len(column)-len(self._table)))\n for i, row in enumerate(self._table):\n row.insert(j, column[i])\n self._table._m += 1 # Increase column count.","def add_column_to_staging_table(cursor,table_schema,table_name,column_name):\n if not check_if_column_exists(cursor, table_schema, table_name, column_name):\n add_column = \"ALTER TABLE \" + table_schema + \".\" + table_name + \" ADD COLUMN \" + column_name + \" text;\"\n cursor.execute(add_column)","def apply_to_table(self, table: Table):\n table.change_column(self.column)","def add_column(self, schema):\n self[schema.name] = schema.copy()","def add_col(self, colname, n_batch=5000, debug=False):\n\n if debug: print(\"Create new column {col}\".format(col=colname))\n # Alter table add column\n #\n alter_query = '''\n ALTER TABLE \"{tablename}\"\n ADD COLUMN \"{colname}\" {datatype};\n '''.format(tablename=self.get_carto_tablename(),\n colname=colname,\n datatype=datatype_map(str(self.dtypes[colname])))\n if debug: print(alter_query)\n\n # add column\n resp = self.carto_sql_client.send(alter_query)\n if debug: print(resp)\n\n # update all the values in that column\n #\n # NOTE: fails if colval is 'inf' or some other exceptional Python\n # or NumPy type\n n_items = len(self[colname])\n update_query = '''\n UPDATE \"{tablename}\"\n SET \"{colname}\" = {colval}\n WHERE \"cartodb_id\" = {cartodb_id};\n '''\n queries = []\n\n for row_num, item in enumerate(self[colname].iteritems()):\n # if debug: print(item)\n pgtype = dtype_to_pgtype(self[colname].dtype, colname)\n temp_query = update_query.format(\n tablename=self.get_carto_tablename(),\n colname=colname,\n colval=numpy_val_to_pg_val(item[1], pgtype),\n cartodb_id=item[0]).strip()\n queries.append(temp_query)\n if (len(queries) == n_batch) or (row_num == n_items - 1):\n output_query = '\\n'.join(queries)\n if debug: print(output_query)\n if debug: print(\"Num chars in query: {}\".format(len(output_query)))\n resp = self.carto_sql_client.send(output_query)\n queries = []\n\n return None","def add_table_column(self, schema, column):\n if not column[\"name\"] or not constants.NAME_RX.match(column[\"name\"]):\n raise ValueError(\"invalid column name\")\n if utils.name_in_nocase(column[\"name\"], [c[\"name\"] for c in schema[\"columns\"]]):\n raise ValueError(\"non-unique column name\")\n if column[\"type\"] not in constants.COLUMN_TYPES:\n raise ValueError(\"invalid column type\")\n sql = (\n f'''ALTER TABLE \"{schema['name']}\"'''\n f\"\"\" ADD COLUMN \"{column['name']}\" {column['type']}\"\"\"\n )\n if column.get(\"notnull\"):\n notnull = [\"NOT NULL\"]\n if column[\"type\"] == constants.INTEGER:\n notnull.append(\"DEFAULT 0\")\n elif column[\"type\"] == constants.REAL:\n notnull.append(\"DEFAULT 0.0\")\n elif column[\"type\"] in (constants.TEXT, constants.BLOB):\n notnull.append(\"DEFAULT ''\")\n sql += \" \" + \" \".join(notnull)\n self.dbcnx.execute(sql)\n schema[\"columns\"].append(column)\n self.update_table(schema)","def addcolumn(self, column):\n if column not in self.headersindex:\n database = managers.database_manager.get_database(self.owner_id, self.database_id)\n cur = database.get_connection().cursor()\n cur.execute(\"ALTER TABLE \\'%s\\' ADD COLUMN %s\" % (self.name, column.to_declaration()))","def insertData(table, column, input):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"INSERT INTO '\" + table + \"' (\" + column + \") VALUES ('\" + input + \"')\")\n\t\tcon.commit()\n\t\tcon.close()\n\texcept:\n\t\tprint('Could not run function insertData from DbController')","def add_column_into_target_sf(self, tap_type, table, new_column):\n self.run_query_target_snowflake(\n f'ALTER TABLE ppw_e2e_tap_{tap_type}{self.sf_schema_postfix}.{table} ADD {new_column[\"name\"]} int'\n )\n self.run_query_target_snowflake(\n f'UPDATE ppw_e2e_tap_{tap_type}{self.sf_schema_postfix}.{table}'\n f' SET {new_column[\"name\"]}={new_column[\"value\"]} WHERE 1=1'\n )","def test_add_column(self):\n name_column = Varchar()\n name_column._meta.name = \"name\"\n\n genre_column = Varchar()\n genre_column._meta.name = \"genre\"\n\n schema: t.List[DiffableTable] = [\n DiffableTable(\n class_name=\"Band\",\n tablename=\"band\",\n columns=[name_column, genre_column],\n )\n ]\n schema_snapshot: t.List[DiffableTable] = [\n DiffableTable(\n class_name=\"Band\",\n tablename=\"band\",\n columns=[name_column],\n )\n ]\n\n schema_differ = SchemaDiffer(\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\"y\"\n )\n\n self.assertTrue(len(schema_differ.add_columns.statements) == 1)\n self.assertEqual(\n schema_differ.add_columns.statements[0],\n \"manager.add_column(table_class_name='Band', tablename='band', column_name='genre', db_column_name='genre', column_class_name='Varchar', column_class=Varchar, params={'length': 255, 'default': '', 'null': False, 'primary_key': False, 'unique': False, 'index': False, 'index_method': IndexMethod.btree, 'choices': None, 'db_column_name': None})\", # noqa\n )","def _add_column_and_format(self, table, label, column):\n table[label] = column\n if label in self._formats:\n table.set_format(label, self._formats[label])","def _addcolumns(self, columnname, columndata=\"\"):\n self[columnname] = columndata","def add_column(self, name, type):\n raise NotImplementedError(\n \"Please implement the 'add_column' method in a derived class.\")","def __setitem__(self,key,value):\n self.table.setItem(key,self.column,value)","def insert(self, tname, valdict, cols = None):\n icmd, vals = make_insert_command(tname, valdict, cols)\n self.write_curs.execute(icmd, vals)","def add_col2tab(con_db, cur_db, tab_name, col_name, col_type):\n\n # Iterate through all existing column names of the database table using\n # the PRAGMA table_info command\n for row in cur_db.execute(f'PRAGMA table_info({tab_name})'):\n\n # If the column exists: exit the function\n if row[1] == col_name:\n break\n\n # If the column is not existing yet, add the new column\n else:\n cur_db.execute(f'ALTER TABLE {tab_name} ' \\\n f'ADD COLUMN {col_name} {col_type}')\n con_db.commit()","def add_columns(self, table, col_data, col_type):\n conn = psycopg2.connect(self.name, sslmode='require')\n c = conn.cursor()\n for data, typ in zip(col_data, col_type):\n c.execute(\"ALTER TABLE {tn} ADD COLUMN {cn} {ct}\".\n format(tn=table, cn=data, ct=typ))\n conn.commit() \n conn.close()","def add_column(self, colspec):\n if colspec.name == DEFAULT_COLUMN_NAME or colspec.name in self.columns.keys():\n raise Exception(\"Column {} already exists.\".format(colspec.name))\n\n self.info.add_column(colspec.name, colspec.video, colspec.dtype)","def __setitem__(self, item, value):\n if value.__class__ is unicode:\n value = value.encode('utf-8')\n value = str(value)\n # If this doesn't change anything, don't record it\n if item in self._original and self._original[item].value == value:\n return\n\n super(ColumnFamily, self).__setitem__(item, value)\n\n if not item in self._columns:\n self._columns[item] = Column(name=item,\n timestamp=time.time())\n\n col = self._columns[item]\n\n if item in self._deleted: del self._deleted[item]\n\n self._modified[item] = True\n col.value, col.timestamp = value, time.time()","def setColumn(self,item,column,value):\n raise UncodedError","def createColumnTable(self, table: Table, column: Column,\n noLine, noColumn):\n database = SymbolTable().useDatabase\n if not database:\n desc = f\": Database not selected\"\n ErrorController().add(4, 'Execution', desc,\n noLine, noColumn)\n return\n\n if self.searchColumn(table, column.name):\n desc = f\": Column {column.name} already exists\"\n ErrorController().add(29, 'Execution', desc, noLine, noColumn)\n return\n\n dbStatement = data_mode.mode(database.mode).alterAddColumn(database.name.lower(), table.name.lower(),\n column.default)\n\n if dbStatement == 0:\n if len(table.columns) > 0:\n column.number = table.columns[-1].number + 1\n\n table.columns.append(column)\n self.writeFile()\n DataWindow().consoleText('Query returned successfully: Table updated')\n return True\n\n elif dbStatement == 1:\n desc = f\": Can't update table {table.name}\"\n ErrorController().add(34, 'Execution', desc, noLine, noColumn)\n\n elif dbStatement == 2:\n desc = f\": Database {database.name} does not exist\"\n ErrorController().add(35, 'Execution', desc, noLine, noColumn)\n\n elif dbStatement == 3:\n desc = f\": Table {table.name} does not exist\"\n ErrorController().add(27, 'Execution', desc, noLine, noColumn)","def InsertColumnInfo(self, before, colInfo):\r\n\r\n if before < 0 or before >= self.GetColumnCount():\r\n raise Exception(\"Invalid column\")\r\n \r\n self._columns.insert(before, colInfo)\r\n self._total_col_width += colInfo.GetWidth()\r\n self._owner.AdjustMyScrollbars()\r\n self._owner._dirty = True","def test_dummydb_add_data_to_table_wrong_column_name(self):\n db = DummyDB()\n columns = {\n \"one\": int,\n \"two\": str,\n \"three\": bool,\n }\n db.create_table(\"new_table\", columns)\n result = db.select(\"new_table\", four=1)","def cols(self, col):\n self.col += col","def addColumnValues(self, column):\n nr1 = self.data.shape[1]\n nr = len(column)\n if nr1 == 0:\n # case 1: empty table\n if nr == 0:\n # case 1a: we're just adding a name\n self.data = numpy.reshape(self.data, (1, 0))\n pass\n else:\n # case 1b: we're adding a column of values\n self.data = numpy.reshape(numpy.array(column), (1, nr))\n pass\n pass\n else:\n # case 2: non-empty table\n if nr1 > 0 and nr != nr1:\n raise Exception(\"New column must have the same length as existing ones %s %s\"%(nr1,nr))\n new_column = numpy.reshape(numpy.array(column), (1, nr))\n self.data = numpy.concatenate((self.data, new_column))\n pass\n return","def add_column(self, name, **kwargs):\n\n import sqlalchemy.orm.session\n from dbexceptions import NotFoundError\n\n s = sqlalchemy.orm.session.Session.object_session(self)\n\n assert s, \"Can't create column with this method unless the table has a session\"\n\n name = Column.mangle_name(name)\n\n if not kwargs.get('fast', False):\n try:\n row = self.column(name)\n except NotFoundError:\n row = None\n else:\n row = None\n\n if row:\n extant = True\n\n else:\n row = Column(self, name=name, **kwargs)\n extant = False\n\n if kwargs.get('data', False):\n row.data = dict(row.data.items() + kwargs['data'].items())\n\n for key, value in kwargs.items():\n\n excludes = ['d_id', 't_id', 'name', 'schema_type', 'data']\n\n # Proto is the name of the object.\n if key == 'proto' and isinstance(value, basestring):\n key = 'proto_vid'\n\n if extant:\n excludes.append('sequence_id')\n\n if key[0] != '_' and key not in excludes:\n try:\n setattr(row, key, value)\n except AttributeError:\n raise AttributeError(\n \"Column record has no attribute {}\".format(key))\n\n if isinstance(value, basestring) and len(value) == 0:\n if key == 'is_primary_key':\n value = False\n setattr(row, key, value)\n\n # If the id column has a description and the table does not, add it to\n # the table.\n if row.name == 'id' and row.is_primary_key and not self.description:\n self.description = row.description\n s.merge(self)\n\n if extant:\n row = s.merge(row)\n else:\n s.add(row)\n\n if kwargs.get('commit', True):\n s.commit()\n\n return row","def AddColumns(sqlite_file, table_name):\r\n columns = ['cf_direct_parent','cf_kingdom','cf_superclass',\\\r\n 'cf_class','cf_subclass','cf_intermediate_0','cf_intermediate_1',\\\r\n 'cf_intermediate_2','cf_intermediate_3','cf_intermediate_4',\\\r\n 'cf_intermediate_5','cf_molecular_framework','cf_alternative_parents',\\\r\n 'cf_substituents', 'cf_description']\r\n column_type = 'TEXT'\r\n # Connecting to the database file\r\n conn = sqlite3.connect(sqlite_file) # Connecting to the database\r\n c = conn.cursor() # Adding a cursor to interact with the database\r\n # Adding new column, if it does not exist yet, without a row value\r\n for new_column_name in columns:\r\n try:\r\n c.execute(\"ALTER TABLE {tn} ADD COLUMN '{cn}' {ct}\"\\\r\n .format(tn=table_name, cn=new_column_name, ct=column_type))\r\n print(\"Column created: {cn}\".format(cn=new_column_name))\r\n except sqlite3.OperationalError:\r\n print(\"Column already exists: {cn}\".format(cn=new_column_name))\r\n conn.commit()\r\n conn.close()\r\n return None","def InsertColumn(self, before, text, width=_DEFAULT_COL_WIDTH,\r\n flag=wx.ALIGN_LEFT, image=-1, shown=True, colour=None, \r\n edit=False):\r\n \r\n colInfo = TreeListColumnInfo(text, width, flag, image, shown, colour, \r\n edit)\r\n self.InsertColumnInfo(before, colInfo)","def add_to_col(self, col: int, data_dict: dict):\n for key, val in data_dict.items():\n self.data.at[key, col] = val","def update_table_column(column, value):\n return cr.update_customer(column, value)","def add_attribute(self, col, attr_name):\n # not optimised: not expected to be a usual operation\n new_table = np.c_[self.np_table, col]\n new_attributes = self.attributes + [attr_name]\n self.__init__(new_table, self.objects, new_attributes)","def InsertColumn(colIndex,name=\"\",label=\"\", Matrix=None):\n if(Matrix == None):\n from globals import Matrix\n\n colToInsertBefore = Matrix.TopAxis.DataMembers[colIndex]\n newColumn = Matrix.InsertBlankColumnAfter(colToInsertBefore,name,label)\n\n Matrix.SwitchColumns(colToInsertBefore.DataIndex,newColumn.DataIndex)\n return Matrix.TopAxis.DataMembers[colIndex]","def set_column(self, column_name, column):\n _key_guard(column_name, 'Column name')\n self._set_column(column_name, column)","def _insert_internal(self, cols, vals) :\n\n self.row_id += 1\n vals[0] = self.row_id\n\n if None in vals :\n cvs = list(zip(cols, vals))\n cvs = [cv for cv in cvs if cv[1] is not None]\n cs = [cv[0] for cv in cvs]\n vs = [cv[1] for cv in cvs]\n else :\n cs = cols\n vs = vals\n\n value_sql = ','.join([self._quoter(cols[i]) % str(vs[i]) \n for i in range(len(vs))])\n\n col_sql = ','.join(['\"%s\"' % c for c in cs])\n insert_sql = 'INSERT INTO \"%s\" (%s) VALUES (%s)' % (self.name, col_sql, value_sql)\n cur = self.con.cursor()\n cur.execute(insert_sql)","def setcolumn(self, column, value, accept_small_names=True):\n if column in self.keys():\n self[column] = value\n return\n elif accept_small_names:\n if self[\"__psvcolumnstracker__\"].get(column):\n self.__setattr__(column, value)\n return\n if not accept_small_names:\n raise ValueError(\"'{}'\".format(column))\n else:\n raise ValueError(\"'{}'. Make sure the shorterned columns name have no collisions\".format(column))","def addColumn(self, name, column):\n self.columnNames.append(name)\n self.addColumnValues(column)","def addColumn(self, aColumn):\n # TODO: Raise exception\n if issubclass(aColumn.__class__, ColumnDefinition):\n self._columns[aColumn.name] = aColumn\n # else:\n # raise exception, not a Column","def column(self, column):\n\n self._column = column","def insert(self):\n pass","def add_table_column(\n self, table: Table, name: Optional[str] = None, values: Any = None\n ):\n self._requires_table(table)\n table.append_column(name, values)","def _insert_op(self, op):","def test_add_column(self):\n self.spy_on(DataGrid.add_column)\n\n DataGridColumnsHook(extension=self.extension,\n datagrid_cls=DataGrid,\n columns=[Column(id='sandbox')])\n\n self.assertTrue(DataGrid.add_column.called)","def add_col_to_df(col, df):\n series = pd.Series(col)\n df['new_column'] = series\n return df","def SetColumn(self, column, info):\r\n \r\n if column < 0 or column >= self.GetColumnCount():\r\n raise Exception(\"Invalid column\")\r\n \r\n w = self._columns[column].GetWidth()\r\n self._columns[column] = info\r\n \r\n if w != info.GetWidth():\r\n self._total_col_width += info.GetWidth() - w\r\n self._owner.AdjustMyScrollbars()\r\n \r\n self._owner._dirty = True","def add_column(self, name, type):\n # Refuse if not in a table\n if self.current_table is None:\n raise NoTableException\n\n self.puml_tables[self.current_table]['default'][name] = type","def add_field(self, table_name, field_name, field_type,\n pk=\"\", default=\"\", not_null=\"\"):\n if not self.open:\n print(\"Not currently connected to a DB.\")\n return False\n\n if pk:\n pk = \" PRIMARY KEY\"\n\n if not_null:\n not_null = \" NOT NULL\"\n\n if not default == \"\":\n default = \" DEFAULT '{}'\".format(default)\n\n q = \"ALTER TABLE {tn} ADD '{fn}' {ft}{df}{pk}{nn}\"\n self.query = q.format(tn=table_name,\n fn=field_name,\n ft=field_type,\n pk=pk,\n df=default,\n nn=not_null)\n\n try:\n self.cursor.execute(self.query)\n print(\"{} column added to {} table.\".format(field_name, table_name))\n return True\n except Exception as error:\n print(\"Failed to add {} to {} table.\".format(field_name, table_name))\n print(\"SQL Query: \\n{}\\n\".format(self.query))\n print(\"Exception: \\n{}\".format(error))\n\n return False","def test_dummydb_add_data_to_table_wrong_column_type(self):\n db = DummyDB()\n columns = {\n \"one\": int,\n \"two\": str,\n \"three\": bool,\n }\n db.create_table(\"new_table\", columns)\n result = db.select(\"new_table\", two=1)","def _set_column(self, column_name, column):\n self._dirty = True\n\n if column.ndim != 1:\n raise ValueError(\"Can only add one-dimensional columns.\")\n if column.dtype.hasobject:\n # Attempting to create a specific non-object based numpy type.\n try:\n first = column[0]\n except IndexError:\n column = np.array([])\n else:\n try:\n # Determining type from the first element.\n if isinstance(first, datetime.datetime):\n # Datetime.\n column = np.array(column, dtype='datetime64[us]')\n elif isinstance(first, datetime.timedelta):\n # Timedelta.\n try:\n column = np.array(column, dtype='timedelta64[us]')\n except TypeError:\n # This exception can occur in numpy 1.9.1 on 32-bit\n # Windows if there is a mix of zero-value and\n # non-zero-value timedeltas. Work around by not\n # converting the zero-value timedeltas to numpy,\n # but using it as the default value instead.\n temp_column = np.zeros_like(\n column, dtype='timedelta64[us]')\n for i, v in enumerate(column):\n if v != datetime.timedelta(0):\n temp_column[i] = v\n column = temp_column\n else:\n # No conversion possible.\n raise ValueError()\n except (ValueError, TypeError):\n raise Exception(\n u'Unsupported object type in column {}'.format(\n column_name))\n\n column = Column(np.array(column))\n self._set_column_column(column_name, column)\n self._number_of_columns = len(column)","def insert_direct(self, key, data, *args, **kwargs):\n return pycassa.ColumnFamily.insert(self, key, data, *args, **kwargs)","def InsertColumnInfo(self, before, colInfo):\r\n\r\n self._header_win.InsertColumnInfo(before, colInfo)\r\n self._header_win.Refresh()","def before_insert(mapper, conn, target):\n\n #from identity import ObjectNumber\n #assert not target.fk_vid or not ObjectNumber.parse(target.fk_vid).revision\n\n if target.sequence_id is None:\n # In case this happens in multi-process mode\n conn.execute(\"BEGIN IMMEDIATE\")\n sql = text(\n '''SELECT max(c_sequence_id)+1 FROM columns WHERE c_t_id = :tid''')\n\n max_id, = conn.execute(sql, tid=target.t_id).fetchone()\n\n if not max_id:\n max_id = 1\n\n target.sequence_id = max_id\n\n Column.before_update(mapper, conn, target)","def add_column(values, df=pandas.DataFrame()):\n df['col_{}'.format(len(df.columns))] = values\n return df","def addcolumn(self, title=\"\"):\n new_column = table_column()\n self.__column_list.append(new_column)\n if title:\n new_column.settitle(title)\n return new_column","def newColumn (layer,FieldName,DataType):\n # Check if field already exists\n if layer.fields().indexFromName(FieldName)==-1:\n caps = layer.dataProvider().capabilities()\n if caps & QgsVectorDataProvider.AddAttributes:\n res = layer.dataProvider().addAttributes([QgsField(FieldName,DataType)])\n print(\"New field \\\"{}\\\" added\".format(FieldName))\n # Update to propagate the changes\n layer.updateFields()\n else:\n print(\"Field \\\"{}\\\" already exists.\".format(FieldName))","def set_table_column(self, table: Table, column: Column, values: Any):\n self._requires_table(table)\n table.set_column(column, values)","def test_dummydb_add_data_to_table(self):\n db = DummyDB()\n columns = {\n \"one\": int,\n \"two\": str,\n \"three\": bool,\n }\n db.create_table(\"new_table\", columns)\n db.insert(\"new_table\", one=1, two=\"haunted\", three=True)\n result = db.select(\"new_table\", one=1)\n self.assertEqual(result[0]['two'], \"haunted\")","def set_col( self, col ):\n self.ix_col = col","def add_col(self):\r\n reader = csv.reader(open(self.in_csvfile, newline=''))\r\n rows = list(reader)\r\n rows[0].append(self.col_name)\r\n for i in range(1, len(rows)):\r\n rows[i].append(self.cell_filler(rows[i]))\r\n writer = csv.writer(open(self.out_csvfile, 'w', newline=''))\r\n writer.writerows(rows)","def AddColumnInfo(self, colInfo):\r\n \r\n self._columns.append(colInfo)\r\n self._total_col_width += colInfo.GetWidth()\r\n self._owner.AdjustMyScrollbars()\r\n self._owner._dirty = True","def insert(self, sql):\n try:\n # Execute the SQL command\n self.cursor.execute(sql)\n # Commit your changes in the database\n self.db.commit()\n except:\n # Rollback in case there is any error\n self.db.rollback()","def append_column(self, column: [str]) -> None:\n self.content.append(column)","def add_column(self, column, replace=False, **kwargs):\n if not isinstance(column, Column):\n raise ValueError('Invalid value. Must be column')\n\n if not hasattr(column, 'id'):\n raise Exception('No id at column')\n\n # We return silently if the column already exists\n if str(column) in self._columns and replace is False:\n # raise Exception('Column \"{0}\" already exists'.format(str(column)))\n return\n\n self._columns[str(column)] = column","def insert_after(self, text, line, col):\n col = self.canonicalize_column_index(line, col)\n col_off = self.col_offs[line]\n adj_col = col_off.get_rewritten_pos(col)\n theline = self.lines[line]\n self.lines[line] = theline[:adj_col] + text + theline[adj_col:]\n col_off.insert(col, len(text))","def insert (self, column, figure):\r\n\t\tc = self.board[column]\r\n\t\tif c[0] != NONE:\r\n\t\t\traise Exception('Column is full')\r\n\r\n\t\ti = -1\r\n\t\twhile c[i] != NONE:\r\n\t\t\ti -= 1\r\n\t\tc[i] = figure\r\n\r\n\t\tself.checkForWin()","def upgrade_alter_table(self, db, tablename, colname, coltype):\n try:\n cursor = db.cursor()\n cursor.execute(\"select %s from %s\" % (colname,tablename))\n except Exception, e:\n self.log.debug(\"upgrade_alter_table: %s\", e)\n cursor = db.cursor()\n alter = \"ALTER TABLE %s add column %s %s\" % (tablename, colname,\n coltype)\n cursor.execute(alter)","def transfer_data(self, column_in, column_out):\n self.open_msfile()\n data_in = self.read_col(column_in)\n self.open_msfile(nomodify=False)\n self.tb.putcol(column_out, data_in)\n self.close_msfile()","def insert(self, data):\r\n pass","def set_column(self,column):\n\t\tif ( not self.validate(1,column)):\n\t\t\treturn\n\t\tself.Grid[column] = 0xff","def add_column(self, pos, char='-', new_label=None):\n MutableAlignment.add_column(self, pos, char)\n if new_label == \"MAX\":\n self._col_labels.insert(pos, max(self._col_labels) + 1)\n elif new_label == \"INC_LAST\":\n self._col_labels.append(max(self._col_labels) + 1)\n elif new_label == \"RESET\":\n self._reset_col_names()\n else:\n self._col_labels.insert(pos, new_label)","def new_column( self, delta = 1, ):\n self.ix_row = 0\n self.ix_col += delta","def row_insert(self, to_insert : LinkedListNode, node_left : LinkedListNode):\r\n self.attach_columns([node_left], [to_insert])","def add_field(self, field_name, field_type):\n field_name = field_name.replace('\"','')\n if field_type == 'keyword':\n query = \"\"\"insert or ignore into keywords\n (_keyword) values (\"%s\")\"\"\" % field_name\n else:\n query = 'alter table files add column \"%s\" %s' % (\n field_name, field_type)\n self.connection.execute(query)\n self.connection.commit()\n self.init_fields()","def _add_column(self, column):\n if column is None:\n column = len(self._columns)\n\n if column in self._columns:\n raise ValueError(f\"Duplicate column name: {column}\")\n\n if isinstance(column, int):\n assert column >= len(self._columns)\n for empty in range(len(self._columns), column):\n self._add_column(empty)\n\n self._columns.append(column)\n for idx in self.index:\n row = self._data[idx]\n row.append(None)\n\n return len(self._columns) - 1","def addStudyActualColumn(self, study_id, column_name, table_name):\n try:\n con = self.getMetadataDatabaseConnection()\n con.cursor().callproc('qiime_assets.add_study_actual_column', [study_id, column_name, table_name])\n except Exception, e: \n raise Exception('Exception caught in addStudyActualColumns(): %s.\\nThe error is: %s' % (type(e), e))","def update_column(conn, table, column, pk_column, pk, value) -> None:\n with conn.cursor() as curs:\n query = sql.SQL('UPDATE {} SET {} = %s WHERE {} = %s').format(sql.Identifier(table), sql.Identifier(column),\n sql.Identifier(pk_column))\n values = (value, pk)\n curs.execute(query, values)\n conn.commit()","def augment_column(self, col: pd.Series,) -> pd.Series:","def insert_values():\n pass","def add_new_column(dataframe, column_name):\r\n dataframe[column_name] = \"\"\r\n return dataframe","def datetime(self, column, nullable=False):\n self._last_column = self.table.add_column(column, \"datetime\", nullable=nullable)\n return self","def alter_column(self, table_name, name, field, explicit_name=True):\r\n # Get the column's SQL\r\n field.set_attributes_from_name(name)\r\n if not explicit_name:\r\n name = field.column\r\n sql = self.column_sql(table_name, name, field)\r\n # Remake the table correctly\r\n self._remake_table(table_name, altered={name: sql})","def _insert_into_new_columns(self, commit, mapping_index):\n for i in range(self.num_new_columns):\n if self.new_columns[i].commit == commit:\n self.mapping[mapping_index] = i\n return mapping_index + 2\n\n # This commit isn't already in new_columns. Add it.\n column = Column(commit, self._find_commit_color(commit))\n self.new_columns[self.num_new_columns] = column\n self.mapping[mapping_index] = self.num_new_columns\n self.num_new_columns += 1\n return mapping_index + 2","def add_column(self, name, display=None):\n column = column_v2()\n column.data.name = name\n column.display.name = display\n self.columns.append(column)\n self.column_length=len(self.columns)\n self.update_ordinals()"],"string":"[\n \"def _addColumn(self, table, column, init_data):\\n\\t\\tcommand = \\\"ALTER TABLE \\\" + table + \\\" ADD COLUMN \\\" + str(column) + \\\" \\\" + getSQLiteType(init_data)\\n\\t\\ttry:\\n\\t\\t\\tself._run_command(command)\\n\\t\\texcept sqlite3.OperationalError:\\n\\t\\t\\tprint(\\\"Column \\\" + str(column) + \\\" already exists!\\\")\",\n \"def insert_column(self):\\n try:\\n lbl_name = Tk.Label(self, text='Enter a column name: ')\\n lbl_name.grid(row=0, column=0, sticky=Tk.W+Tk.E)\\n ent_name = Tk.Entry(self)\\n ent_name.grid(row=0, column=1, sticky=Tk.W+Tk.E)\\n lbl_type = Tk.Label(self, text='Enter a column type: ')\\n lbl_type.grid(row=1, column=0, sticky=Tk.W+Tk.E)\\n ent_type = Tk.Entry(self)\\n ent_type.grid(row=1, column=1, sticky=Tk.W+Tk.E)\\n\\n def _insert_column():\\n c_name = ent_name.get()\\n c_type = ent_type.get()\\n self.parent.insert_column(self.parent.table, c_name, c_type)\\n self.destroy()\\n self.parent.populate_display()\\n b_ins = Tk.Button(self,\\n text='Insert Column',\\n command=_insert_column)\\\\\\n .grid(row=2, column=1, sticky=Tk.W+Tk.E)\\n except Exception, ex:\\n logging.error(ex)\\n traceback.print_exc()\",\n \"def add_column(self, tap_column):\\r\\n self.__columns.append(tap_column)\",\n \"def add_column(self, fieldname, column, align=..., valign=...):\\n ...\",\n \"def insert_column(self, column_name, column_type, table, params=None, overwrite=False, after_col=None, verbose=True):\\n \\n assert(self.connected)\\n \\n try: assert(self.check_table(table, verbose=False)) \\n except AssertionError: raise TableNotFoundError\\n \\n \\n \\n if self.check_column(column_name, table, verbose=False): \\n \\n if not overwrite:\\n \\n if verbose: print(\\\"The column '{0}' already exists in the table '{1}'.\\\".format(column_name, table))\\n return False\\n \\n else:\\n \\n if verbose: \\n print(\\\"The column '{0}' already exists in the table '{1}'.\\\".format(column_name, table))\\n \\n self.delete_column(column_name,table,verbose=True)\\n \\n self._insert_column(column_name, column_type, table, params, overwrite, after_col)\\n \\n else:\\n \\n self._insert_column(column_name, column_type, table, params, overwrite, after_col)\\n \\n \\n if verbose: print(\\\"Column '{0}' added to the table '{1}' successfully.\\\".format(column_name, table))\\n \\n return True\",\n \"def _insert_column(self, column_name, column_type, table, params=None, overwrite=False, after_col=None, verbose=True):\\n \\n not_null = ''\\n auto_increment = ''\\n \\n if params != None and 'not_null' in params:\\n not_null = 'NOT NULL'\\n \\n \\n if params != None and 'auto_increment' in params:\\n auto_increment = \\\"AUTO_INCREMENT\\\"\\n \\n \\n ADD_COLUMN_COMMAND = \\\"ALTER TABLE {0} ADD {1} {2} {3} {4}\\\".format(table, column_name, column_type, not_null, auto_increment)\\n \\n if (after_col != None and type(after_col) is str):\\n ADD_COLUMN_COMMAND += \\\" AFTER {0} \\\".format(after_col)\\n \\n \\n self.cursor.execute(ADD_COLUMN_COMMAND)\\n \\n if verbose: \\n print(\\\"Adding the column '{0}' to the table '{1}'...\\\".format(column_name, table))\\n print(\\\"\\\\t\\\" + ADD_COLUMN_COMMAND) \\n \\n \\n if params != None and 'foreign_key' in params:\\n \\n if 'references' not in params:\\n raise InvalidParameterError\\n \\n referenced_table = params['references'].split('(')[0]\\n referenced_column = params['references'].split('(')[1][:-1] \\n \\n \\n if (not self.check_table(referenced_table, verbose=False)):\\n raise(TableNotFoundError)\\n \\n \\n if (not self.check_column(referenced_column, referenced_table, verbose=False)):\\n raise(ColumnNotFoundError)\\n \\n \\n ADD_FOREIGN_KEY_COMMAND = \\\"ALTER TABLE {0} ADD FOREIGN KEY ({1}) REFERENCES {2}({3})\\\".format(table, column_name, referenced_table, referenced_column)\\n \\n \\n if verbose: \\n print(\\\"\\\\t\\\" + ADD_FOREIGN_KEY_COMMAND) \\n \\n self.cursor.execute(ADD_FOREIGN_KEY_COMMAND)\",\n \"def addColumn(self, *column):\\n self.insertColumn(self._width, *column)\",\n \"def add_column_into_source(self, tap_type, table, new_column):\\n run_query_method = getattr(self, f'run_query_tap_{tap_type}')\\n run_query_method(\\n f'ALTER TABLE {table} ADD {new_column[\\\"name\\\"]} int'\\n )\\n run_query_method(\\n f'UPDATE {table} set {new_column[\\\"name\\\"]}={new_column[\\\"value\\\"]} where 1=1'\\n )\",\n \"def create_column(self, new_column, dtype):\\n self.logger.debug(\\\"[%u] Ready to add column %s\\\" %\\n (os.getpid(), new_column))\\n ddl = \\\"\\\"\\\"\\n ALTER TABLE {schema}.{table}\\n ADD COLUMN IF NOT EXISTS {col} {type}\\n \\\"\\\"\\\"\\n # TODO Replace by execute_ddl func and test it\\n with get_sink_connection_string(self) as conn:\\n with conn.cursor() as cursor:\\n cursor.execute(ddl.format(schema=self.config['schema'],\\n table=self.config['table'],\\n col=new_column,\\n type=dtype))\\n self.logger.debug(\\\"[%u] Column %s has been added\\\" %\\n (os.getpid(), new_column))\",\n \"def AddColumn(self, column):\\n self.columns.append(column)\\n self.column_dict[column.column_id] = column\",\n \"def insertColumn(self, index, *column):\\n if ((len(column) == 1) and (type(column[0]) in MATRIX_VALID_COLLECTIONS)):\\n column = column[0]\\n if self._height:\\n if not (len(column) == self._height):\\n raise ValueError('Improper length for new column: %d, should be %d' % (len(column), self._height))\\n else:\\n self._height = len(column)\\n for i in range(self._height):\\n self._value.append(list())\\n self._width += 1\\n for i in range(self._height):\\n if not (type(column[i]) in MATRIX_VALID_TYPES):\\n message = \\\"Values must be of type \\\"\\n for t in range(len(MATRIX_VALID_TYPENAMES)):\\n if t:\\n message += ' or '\\n message += \\\"'%s'\\\" % MATRIX_VALID_TYPENAMES[t]\\n raise TypeError(message)\\n self._value[i].insert(index, column[i])\",\n \"def insert_column(self, identifier, position, name, datastore):\\n # Raise ValueError if given colum name is invalid.\\n if name is not None and not is_valid_name(name):\\n raise ValueError(\\\"invalid column name '{}'\\\".format(name))\\n # Get dataset. Raise exception if dataset is unknown.\\n dataset = datastore.get_dataset(identifier)\\n if dataset is None:\\n raise ValueError(\\\"unknown dataset '{}'\\\".format(identifier))\\n # Insert new column into dataset.\\n df = dataset.to_dataframe()\\n df = vizual.insert_column(df=df, names=[name], pos=position)\\n # Store updated dataset to get new identifier.\\n ds = datastore.update_dataset(\\n origin=dataset,\\n df=df,\\n annotations=dataset.annotations\\n )\\n return VizualApiResult(ds)\",\n \"def addcolumn(self, colname, coldata):\\n if len(coldata) != len(self):\\n raise ValueError,\\\"Column length must match catalog length\\\"\\n\\n #Most of the bookkeeping is the same as for an empty column\\n self.addemptycolumn(colname,coldata.dtype)\\n\\n #and then we reset the column to contain the actual data\\n setattr(self,colname,coldata)\",\n \"def add_column(self, table_name: str, column) -> None:\\n sql = 'ALTER TABLE ' + table_name + ' ADD COLUMN ' + column.to_sql()\\n self.cursor.execute(sql)\",\n \"def setCol(self, col):\\n self.column = col\",\n \"def addTableColumn(self, tablename, columnname, columntype):\\n\\n # Check if the table exists\\n if tablename in self.getTableNames():\\n\\n # Check that the column does not already exist\\n if columnname not in self.getColumnNames(tablename):\\n\\n #Allow columnames with spaces\\n columnname = '`'+columnname+'`'\\n\\n \\\"\\\"\\\"# Fit characters to the allowed format if necessary\\n fmt = ''\\n if (self.connector == 'mysql' and\\n ('TEXT' in columntype or 'VARCHAR' in columntype) and\\n not ('CHARACTER SET' in columntype or\\n 'utf8mb4' in columntype)):\\n\\n # We enforze utf8mb4 for mysql\\n fmt = ' CHARACTER SET utf8mb4'\\n\\n\\n sqlcmd = ('ALTER TABLE ' + tablename + ' ADD COLUMN ' +\\n columnname + ' ' + columntype + fmt)\\\"\\\"\\\"\\n sqlcmd = ('ALTER TABLE ' + tablename + ' ADD COLUMN ' +\\n columnname + ' ' + columntype) \\n self._c.execute(sqlcmd)\\n\\n # Commit changes\\n self._conn.commit()\\n\\n else:\\n print((\\\"WARNING: Column {0} already exists in table {1}.\\\"\\n ).format(columnname, tablename))\\n\\n else:\\n print('Error adding column to table. Please, select a valid ' +\\n 'table name from the list')\\n print(self.getTableNames())\\n\\n return\",\n \"def insert_column(df, colTitle, colIndex, fillValue):\\n if colTitle not in df.columns:\\n df.insert(colIndex, colTitle, fillValue, True)\\n return df\",\n \"def add_column(self, col_name, definition):\\n if not self.column_exists(col_name):\\n self.execute(self.commands.add_column(self.name, col_name, definition))\",\n \"def insert(self, j, column, default=None):\\n try: column = [v for v in column]\\n except:\\n raise TypeError, \\\"Table.columns.insert(x): x must be list\\\"\\n column = column + [default] * (len(self._table) - len(column))\\n if len(column) > len(self._table):\\n self._table.extend([[None]] * (len(column)-len(self._table)))\\n for i, row in enumerate(self._table):\\n row.insert(j, column[i])\\n self._table._m += 1 # Increase column count.\",\n \"def add_column_to_staging_table(cursor,table_schema,table_name,column_name):\\n if not check_if_column_exists(cursor, table_schema, table_name, column_name):\\n add_column = \\\"ALTER TABLE \\\" + table_schema + \\\".\\\" + table_name + \\\" ADD COLUMN \\\" + column_name + \\\" text;\\\"\\n cursor.execute(add_column)\",\n \"def apply_to_table(self, table: Table):\\n table.change_column(self.column)\",\n \"def add_column(self, schema):\\n self[schema.name] = schema.copy()\",\n \"def add_col(self, colname, n_batch=5000, debug=False):\\n\\n if debug: print(\\\"Create new column {col}\\\".format(col=colname))\\n # Alter table add column\\n #\\n alter_query = '''\\n ALTER TABLE \\\"{tablename}\\\"\\n ADD COLUMN \\\"{colname}\\\" {datatype};\\n '''.format(tablename=self.get_carto_tablename(),\\n colname=colname,\\n datatype=datatype_map(str(self.dtypes[colname])))\\n if debug: print(alter_query)\\n\\n # add column\\n resp = self.carto_sql_client.send(alter_query)\\n if debug: print(resp)\\n\\n # update all the values in that column\\n #\\n # NOTE: fails if colval is 'inf' or some other exceptional Python\\n # or NumPy type\\n n_items = len(self[colname])\\n update_query = '''\\n UPDATE \\\"{tablename}\\\"\\n SET \\\"{colname}\\\" = {colval}\\n WHERE \\\"cartodb_id\\\" = {cartodb_id};\\n '''\\n queries = []\\n\\n for row_num, item in enumerate(self[colname].iteritems()):\\n # if debug: print(item)\\n pgtype = dtype_to_pgtype(self[colname].dtype, colname)\\n temp_query = update_query.format(\\n tablename=self.get_carto_tablename(),\\n colname=colname,\\n colval=numpy_val_to_pg_val(item[1], pgtype),\\n cartodb_id=item[0]).strip()\\n queries.append(temp_query)\\n if (len(queries) == n_batch) or (row_num == n_items - 1):\\n output_query = '\\\\n'.join(queries)\\n if debug: print(output_query)\\n if debug: print(\\\"Num chars in query: {}\\\".format(len(output_query)))\\n resp = self.carto_sql_client.send(output_query)\\n queries = []\\n\\n return None\",\n \"def add_table_column(self, schema, column):\\n if not column[\\\"name\\\"] or not constants.NAME_RX.match(column[\\\"name\\\"]):\\n raise ValueError(\\\"invalid column name\\\")\\n if utils.name_in_nocase(column[\\\"name\\\"], [c[\\\"name\\\"] for c in schema[\\\"columns\\\"]]):\\n raise ValueError(\\\"non-unique column name\\\")\\n if column[\\\"type\\\"] not in constants.COLUMN_TYPES:\\n raise ValueError(\\\"invalid column type\\\")\\n sql = (\\n f'''ALTER TABLE \\\"{schema['name']}\\\"'''\\n f\\\"\\\"\\\" ADD COLUMN \\\"{column['name']}\\\" {column['type']}\\\"\\\"\\\"\\n )\\n if column.get(\\\"notnull\\\"):\\n notnull = [\\\"NOT NULL\\\"]\\n if column[\\\"type\\\"] == constants.INTEGER:\\n notnull.append(\\\"DEFAULT 0\\\")\\n elif column[\\\"type\\\"] == constants.REAL:\\n notnull.append(\\\"DEFAULT 0.0\\\")\\n elif column[\\\"type\\\"] in (constants.TEXT, constants.BLOB):\\n notnull.append(\\\"DEFAULT ''\\\")\\n sql += \\\" \\\" + \\\" \\\".join(notnull)\\n self.dbcnx.execute(sql)\\n schema[\\\"columns\\\"].append(column)\\n self.update_table(schema)\",\n \"def addcolumn(self, column):\\n if column not in self.headersindex:\\n database = managers.database_manager.get_database(self.owner_id, self.database_id)\\n cur = database.get_connection().cursor()\\n cur.execute(\\\"ALTER TABLE \\\\'%s\\\\' ADD COLUMN %s\\\" % (self.name, column.to_declaration()))\",\n \"def insertData(table, column, input):\\n\\ttry:\\n\\t\\tcon = sqlite3.connect('PampDb.db')\\n\\t\\tcur = con.cursor()\\n\\t\\tcur.execute(\\\"INSERT INTO '\\\" + table + \\\"' (\\\" + column + \\\") VALUES ('\\\" + input + \\\"')\\\")\\n\\t\\tcon.commit()\\n\\t\\tcon.close()\\n\\texcept:\\n\\t\\tprint('Could not run function insertData from DbController')\",\n \"def add_column_into_target_sf(self, tap_type, table, new_column):\\n self.run_query_target_snowflake(\\n f'ALTER TABLE ppw_e2e_tap_{tap_type}{self.sf_schema_postfix}.{table} ADD {new_column[\\\"name\\\"]} int'\\n )\\n self.run_query_target_snowflake(\\n f'UPDATE ppw_e2e_tap_{tap_type}{self.sf_schema_postfix}.{table}'\\n f' SET {new_column[\\\"name\\\"]}={new_column[\\\"value\\\"]} WHERE 1=1'\\n )\",\n \"def test_add_column(self):\\n name_column = Varchar()\\n name_column._meta.name = \\\"name\\\"\\n\\n genre_column = Varchar()\\n genre_column._meta.name = \\\"genre\\\"\\n\\n schema: t.List[DiffableTable] = [\\n DiffableTable(\\n class_name=\\\"Band\\\",\\n tablename=\\\"band\\\",\\n columns=[name_column, genre_column],\\n )\\n ]\\n schema_snapshot: t.List[DiffableTable] = [\\n DiffableTable(\\n class_name=\\\"Band\\\",\\n tablename=\\\"band\\\",\\n columns=[name_column],\\n )\\n ]\\n\\n schema_differ = SchemaDiffer(\\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\\\"y\\\"\\n )\\n\\n self.assertTrue(len(schema_differ.add_columns.statements) == 1)\\n self.assertEqual(\\n schema_differ.add_columns.statements[0],\\n \\\"manager.add_column(table_class_name='Band', tablename='band', column_name='genre', db_column_name='genre', column_class_name='Varchar', column_class=Varchar, params={'length': 255, 'default': '', 'null': False, 'primary_key': False, 'unique': False, 'index': False, 'index_method': IndexMethod.btree, 'choices': None, 'db_column_name': None})\\\", # noqa\\n )\",\n \"def _add_column_and_format(self, table, label, column):\\n table[label] = column\\n if label in self._formats:\\n table.set_format(label, self._formats[label])\",\n \"def _addcolumns(self, columnname, columndata=\\\"\\\"):\\n self[columnname] = columndata\",\n \"def add_column(self, name, type):\\n raise NotImplementedError(\\n \\\"Please implement the 'add_column' method in a derived class.\\\")\",\n \"def __setitem__(self,key,value):\\n self.table.setItem(key,self.column,value)\",\n \"def insert(self, tname, valdict, cols = None):\\n icmd, vals = make_insert_command(tname, valdict, cols)\\n self.write_curs.execute(icmd, vals)\",\n \"def add_col2tab(con_db, cur_db, tab_name, col_name, col_type):\\n\\n # Iterate through all existing column names of the database table using\\n # the PRAGMA table_info command\\n for row in cur_db.execute(f'PRAGMA table_info({tab_name})'):\\n\\n # If the column exists: exit the function\\n if row[1] == col_name:\\n break\\n\\n # If the column is not existing yet, add the new column\\n else:\\n cur_db.execute(f'ALTER TABLE {tab_name} ' \\\\\\n f'ADD COLUMN {col_name} {col_type}')\\n con_db.commit()\",\n \"def add_columns(self, table, col_data, col_type):\\n conn = psycopg2.connect(self.name, sslmode='require')\\n c = conn.cursor()\\n for data, typ in zip(col_data, col_type):\\n c.execute(\\\"ALTER TABLE {tn} ADD COLUMN {cn} {ct}\\\".\\n format(tn=table, cn=data, ct=typ))\\n conn.commit() \\n conn.close()\",\n \"def add_column(self, colspec):\\n if colspec.name == DEFAULT_COLUMN_NAME or colspec.name in self.columns.keys():\\n raise Exception(\\\"Column {} already exists.\\\".format(colspec.name))\\n\\n self.info.add_column(colspec.name, colspec.video, colspec.dtype)\",\n \"def __setitem__(self, item, value):\\n if value.__class__ is unicode:\\n value = value.encode('utf-8')\\n value = str(value)\\n # If this doesn't change anything, don't record it\\n if item in self._original and self._original[item].value == value:\\n return\\n\\n super(ColumnFamily, self).__setitem__(item, value)\\n\\n if not item in self._columns:\\n self._columns[item] = Column(name=item,\\n timestamp=time.time())\\n\\n col = self._columns[item]\\n\\n if item in self._deleted: del self._deleted[item]\\n\\n self._modified[item] = True\\n col.value, col.timestamp = value, time.time()\",\n \"def setColumn(self,item,column,value):\\n raise UncodedError\",\n \"def createColumnTable(self, table: Table, column: Column,\\n noLine, noColumn):\\n database = SymbolTable().useDatabase\\n if not database:\\n desc = f\\\": Database not selected\\\"\\n ErrorController().add(4, 'Execution', desc,\\n noLine, noColumn)\\n return\\n\\n if self.searchColumn(table, column.name):\\n desc = f\\\": Column {column.name} already exists\\\"\\n ErrorController().add(29, 'Execution', desc, noLine, noColumn)\\n return\\n\\n dbStatement = data_mode.mode(database.mode).alterAddColumn(database.name.lower(), table.name.lower(),\\n column.default)\\n\\n if dbStatement == 0:\\n if len(table.columns) > 0:\\n column.number = table.columns[-1].number + 1\\n\\n table.columns.append(column)\\n self.writeFile()\\n DataWindow().consoleText('Query returned successfully: Table updated')\\n return True\\n\\n elif dbStatement == 1:\\n desc = f\\\": Can't update table {table.name}\\\"\\n ErrorController().add(34, 'Execution', desc, noLine, noColumn)\\n\\n elif dbStatement == 2:\\n desc = f\\\": Database {database.name} does not exist\\\"\\n ErrorController().add(35, 'Execution', desc, noLine, noColumn)\\n\\n elif dbStatement == 3:\\n desc = f\\\": Table {table.name} does not exist\\\"\\n ErrorController().add(27, 'Execution', desc, noLine, noColumn)\",\n \"def InsertColumnInfo(self, before, colInfo):\\r\\n\\r\\n if before < 0 or before >= self.GetColumnCount():\\r\\n raise Exception(\\\"Invalid column\\\")\\r\\n \\r\\n self._columns.insert(before, colInfo)\\r\\n self._total_col_width += colInfo.GetWidth()\\r\\n self._owner.AdjustMyScrollbars()\\r\\n self._owner._dirty = True\",\n \"def test_dummydb_add_data_to_table_wrong_column_name(self):\\n db = DummyDB()\\n columns = {\\n \\\"one\\\": int,\\n \\\"two\\\": str,\\n \\\"three\\\": bool,\\n }\\n db.create_table(\\\"new_table\\\", columns)\\n result = db.select(\\\"new_table\\\", four=1)\",\n \"def cols(self, col):\\n self.col += col\",\n \"def addColumnValues(self, column):\\n nr1 = self.data.shape[1]\\n nr = len(column)\\n if nr1 == 0:\\n # case 1: empty table\\n if nr == 0:\\n # case 1a: we're just adding a name\\n self.data = numpy.reshape(self.data, (1, 0))\\n pass\\n else:\\n # case 1b: we're adding a column of values\\n self.data = numpy.reshape(numpy.array(column), (1, nr))\\n pass\\n pass\\n else:\\n # case 2: non-empty table\\n if nr1 > 0 and nr != nr1:\\n raise Exception(\\\"New column must have the same length as existing ones %s %s\\\"%(nr1,nr))\\n new_column = numpy.reshape(numpy.array(column), (1, nr))\\n self.data = numpy.concatenate((self.data, new_column))\\n pass\\n return\",\n \"def add_column(self, name, **kwargs):\\n\\n import sqlalchemy.orm.session\\n from dbexceptions import NotFoundError\\n\\n s = sqlalchemy.orm.session.Session.object_session(self)\\n\\n assert s, \\\"Can't create column with this method unless the table has a session\\\"\\n\\n name = Column.mangle_name(name)\\n\\n if not kwargs.get('fast', False):\\n try:\\n row = self.column(name)\\n except NotFoundError:\\n row = None\\n else:\\n row = None\\n\\n if row:\\n extant = True\\n\\n else:\\n row = Column(self, name=name, **kwargs)\\n extant = False\\n\\n if kwargs.get('data', False):\\n row.data = dict(row.data.items() + kwargs['data'].items())\\n\\n for key, value in kwargs.items():\\n\\n excludes = ['d_id', 't_id', 'name', 'schema_type', 'data']\\n\\n # Proto is the name of the object.\\n if key == 'proto' and isinstance(value, basestring):\\n key = 'proto_vid'\\n\\n if extant:\\n excludes.append('sequence_id')\\n\\n if key[0] != '_' and key not in excludes:\\n try:\\n setattr(row, key, value)\\n except AttributeError:\\n raise AttributeError(\\n \\\"Column record has no attribute {}\\\".format(key))\\n\\n if isinstance(value, basestring) and len(value) == 0:\\n if key == 'is_primary_key':\\n value = False\\n setattr(row, key, value)\\n\\n # If the id column has a description and the table does not, add it to\\n # the table.\\n if row.name == 'id' and row.is_primary_key and not self.description:\\n self.description = row.description\\n s.merge(self)\\n\\n if extant:\\n row = s.merge(row)\\n else:\\n s.add(row)\\n\\n if kwargs.get('commit', True):\\n s.commit()\\n\\n return row\",\n \"def AddColumns(sqlite_file, table_name):\\r\\n columns = ['cf_direct_parent','cf_kingdom','cf_superclass',\\\\\\r\\n 'cf_class','cf_subclass','cf_intermediate_0','cf_intermediate_1',\\\\\\r\\n 'cf_intermediate_2','cf_intermediate_3','cf_intermediate_4',\\\\\\r\\n 'cf_intermediate_5','cf_molecular_framework','cf_alternative_parents',\\\\\\r\\n 'cf_substituents', 'cf_description']\\r\\n column_type = 'TEXT'\\r\\n # Connecting to the database file\\r\\n conn = sqlite3.connect(sqlite_file) # Connecting to the database\\r\\n c = conn.cursor() # Adding a cursor to interact with the database\\r\\n # Adding new column, if it does not exist yet, without a row value\\r\\n for new_column_name in columns:\\r\\n try:\\r\\n c.execute(\\\"ALTER TABLE {tn} ADD COLUMN '{cn}' {ct}\\\"\\\\\\r\\n .format(tn=table_name, cn=new_column_name, ct=column_type))\\r\\n print(\\\"Column created: {cn}\\\".format(cn=new_column_name))\\r\\n except sqlite3.OperationalError:\\r\\n print(\\\"Column already exists: {cn}\\\".format(cn=new_column_name))\\r\\n conn.commit()\\r\\n conn.close()\\r\\n return None\",\n \"def InsertColumn(self, before, text, width=_DEFAULT_COL_WIDTH,\\r\\n flag=wx.ALIGN_LEFT, image=-1, shown=True, colour=None, \\r\\n edit=False):\\r\\n \\r\\n colInfo = TreeListColumnInfo(text, width, flag, image, shown, colour, \\r\\n edit)\\r\\n self.InsertColumnInfo(before, colInfo)\",\n \"def add_to_col(self, col: int, data_dict: dict):\\n for key, val in data_dict.items():\\n self.data.at[key, col] = val\",\n \"def update_table_column(column, value):\\n return cr.update_customer(column, value)\",\n \"def add_attribute(self, col, attr_name):\\n # not optimised: not expected to be a usual operation\\n new_table = np.c_[self.np_table, col]\\n new_attributes = self.attributes + [attr_name]\\n self.__init__(new_table, self.objects, new_attributes)\",\n \"def InsertColumn(colIndex,name=\\\"\\\",label=\\\"\\\", Matrix=None):\\n if(Matrix == None):\\n from globals import Matrix\\n\\n colToInsertBefore = Matrix.TopAxis.DataMembers[colIndex]\\n newColumn = Matrix.InsertBlankColumnAfter(colToInsertBefore,name,label)\\n\\n Matrix.SwitchColumns(colToInsertBefore.DataIndex,newColumn.DataIndex)\\n return Matrix.TopAxis.DataMembers[colIndex]\",\n \"def set_column(self, column_name, column):\\n _key_guard(column_name, 'Column name')\\n self._set_column(column_name, column)\",\n \"def _insert_internal(self, cols, vals) :\\n\\n self.row_id += 1\\n vals[0] = self.row_id\\n\\n if None in vals :\\n cvs = list(zip(cols, vals))\\n cvs = [cv for cv in cvs if cv[1] is not None]\\n cs = [cv[0] for cv in cvs]\\n vs = [cv[1] for cv in cvs]\\n else :\\n cs = cols\\n vs = vals\\n\\n value_sql = ','.join([self._quoter(cols[i]) % str(vs[i]) \\n for i in range(len(vs))])\\n\\n col_sql = ','.join(['\\\"%s\\\"' % c for c in cs])\\n insert_sql = 'INSERT INTO \\\"%s\\\" (%s) VALUES (%s)' % (self.name, col_sql, value_sql)\\n cur = self.con.cursor()\\n cur.execute(insert_sql)\",\n \"def setcolumn(self, column, value, accept_small_names=True):\\n if column in self.keys():\\n self[column] = value\\n return\\n elif accept_small_names:\\n if self[\\\"__psvcolumnstracker__\\\"].get(column):\\n self.__setattr__(column, value)\\n return\\n if not accept_small_names:\\n raise ValueError(\\\"'{}'\\\".format(column))\\n else:\\n raise ValueError(\\\"'{}'. Make sure the shorterned columns name have no collisions\\\".format(column))\",\n \"def addColumn(self, name, column):\\n self.columnNames.append(name)\\n self.addColumnValues(column)\",\n \"def addColumn(self, aColumn):\\n # TODO: Raise exception\\n if issubclass(aColumn.__class__, ColumnDefinition):\\n self._columns[aColumn.name] = aColumn\\n # else:\\n # raise exception, not a Column\",\n \"def column(self, column):\\n\\n self._column = column\",\n \"def insert(self):\\n pass\",\n \"def add_table_column(\\n self, table: Table, name: Optional[str] = None, values: Any = None\\n ):\\n self._requires_table(table)\\n table.append_column(name, values)\",\n \"def _insert_op(self, op):\",\n \"def test_add_column(self):\\n self.spy_on(DataGrid.add_column)\\n\\n DataGridColumnsHook(extension=self.extension,\\n datagrid_cls=DataGrid,\\n columns=[Column(id='sandbox')])\\n\\n self.assertTrue(DataGrid.add_column.called)\",\n \"def add_col_to_df(col, df):\\n series = pd.Series(col)\\n df['new_column'] = series\\n return df\",\n \"def SetColumn(self, column, info):\\r\\n \\r\\n if column < 0 or column >= self.GetColumnCount():\\r\\n raise Exception(\\\"Invalid column\\\")\\r\\n \\r\\n w = self._columns[column].GetWidth()\\r\\n self._columns[column] = info\\r\\n \\r\\n if w != info.GetWidth():\\r\\n self._total_col_width += info.GetWidth() - w\\r\\n self._owner.AdjustMyScrollbars()\\r\\n \\r\\n self._owner._dirty = True\",\n \"def add_column(self, name, type):\\n # Refuse if not in a table\\n if self.current_table is None:\\n raise NoTableException\\n\\n self.puml_tables[self.current_table]['default'][name] = type\",\n \"def add_field(self, table_name, field_name, field_type,\\n pk=\\\"\\\", default=\\\"\\\", not_null=\\\"\\\"):\\n if not self.open:\\n print(\\\"Not currently connected to a DB.\\\")\\n return False\\n\\n if pk:\\n pk = \\\" PRIMARY KEY\\\"\\n\\n if not_null:\\n not_null = \\\" NOT NULL\\\"\\n\\n if not default == \\\"\\\":\\n default = \\\" DEFAULT '{}'\\\".format(default)\\n\\n q = \\\"ALTER TABLE {tn} ADD '{fn}' {ft}{df}{pk}{nn}\\\"\\n self.query = q.format(tn=table_name,\\n fn=field_name,\\n ft=field_type,\\n pk=pk,\\n df=default,\\n nn=not_null)\\n\\n try:\\n self.cursor.execute(self.query)\\n print(\\\"{} column added to {} table.\\\".format(field_name, table_name))\\n return True\\n except Exception as error:\\n print(\\\"Failed to add {} to {} table.\\\".format(field_name, table_name))\\n print(\\\"SQL Query: \\\\n{}\\\\n\\\".format(self.query))\\n print(\\\"Exception: \\\\n{}\\\".format(error))\\n\\n return False\",\n \"def test_dummydb_add_data_to_table_wrong_column_type(self):\\n db = DummyDB()\\n columns = {\\n \\\"one\\\": int,\\n \\\"two\\\": str,\\n \\\"three\\\": bool,\\n }\\n db.create_table(\\\"new_table\\\", columns)\\n result = db.select(\\\"new_table\\\", two=1)\",\n \"def _set_column(self, column_name, column):\\n self._dirty = True\\n\\n if column.ndim != 1:\\n raise ValueError(\\\"Can only add one-dimensional columns.\\\")\\n if column.dtype.hasobject:\\n # Attempting to create a specific non-object based numpy type.\\n try:\\n first = column[0]\\n except IndexError:\\n column = np.array([])\\n else:\\n try:\\n # Determining type from the first element.\\n if isinstance(first, datetime.datetime):\\n # Datetime.\\n column = np.array(column, dtype='datetime64[us]')\\n elif isinstance(first, datetime.timedelta):\\n # Timedelta.\\n try:\\n column = np.array(column, dtype='timedelta64[us]')\\n except TypeError:\\n # This exception can occur in numpy 1.9.1 on 32-bit\\n # Windows if there is a mix of zero-value and\\n # non-zero-value timedeltas. Work around by not\\n # converting the zero-value timedeltas to numpy,\\n # but using it as the default value instead.\\n temp_column = np.zeros_like(\\n column, dtype='timedelta64[us]')\\n for i, v in enumerate(column):\\n if v != datetime.timedelta(0):\\n temp_column[i] = v\\n column = temp_column\\n else:\\n # No conversion possible.\\n raise ValueError()\\n except (ValueError, TypeError):\\n raise Exception(\\n u'Unsupported object type in column {}'.format(\\n column_name))\\n\\n column = Column(np.array(column))\\n self._set_column_column(column_name, column)\\n self._number_of_columns = len(column)\",\n \"def insert_direct(self, key, data, *args, **kwargs):\\n return pycassa.ColumnFamily.insert(self, key, data, *args, **kwargs)\",\n \"def InsertColumnInfo(self, before, colInfo):\\r\\n\\r\\n self._header_win.InsertColumnInfo(before, colInfo)\\r\\n self._header_win.Refresh()\",\n \"def before_insert(mapper, conn, target):\\n\\n #from identity import ObjectNumber\\n #assert not target.fk_vid or not ObjectNumber.parse(target.fk_vid).revision\\n\\n if target.sequence_id is None:\\n # In case this happens in multi-process mode\\n conn.execute(\\\"BEGIN IMMEDIATE\\\")\\n sql = text(\\n '''SELECT max(c_sequence_id)+1 FROM columns WHERE c_t_id = :tid''')\\n\\n max_id, = conn.execute(sql, tid=target.t_id).fetchone()\\n\\n if not max_id:\\n max_id = 1\\n\\n target.sequence_id = max_id\\n\\n Column.before_update(mapper, conn, target)\",\n \"def add_column(values, df=pandas.DataFrame()):\\n df['col_{}'.format(len(df.columns))] = values\\n return df\",\n \"def addcolumn(self, title=\\\"\\\"):\\n new_column = table_column()\\n self.__column_list.append(new_column)\\n if title:\\n new_column.settitle(title)\\n return new_column\",\n \"def newColumn (layer,FieldName,DataType):\\n # Check if field already exists\\n if layer.fields().indexFromName(FieldName)==-1:\\n caps = layer.dataProvider().capabilities()\\n if caps & QgsVectorDataProvider.AddAttributes:\\n res = layer.dataProvider().addAttributes([QgsField(FieldName,DataType)])\\n print(\\\"New field \\\\\\\"{}\\\\\\\" added\\\".format(FieldName))\\n # Update to propagate the changes\\n layer.updateFields()\\n else:\\n print(\\\"Field \\\\\\\"{}\\\\\\\" already exists.\\\".format(FieldName))\",\n \"def set_table_column(self, table: Table, column: Column, values: Any):\\n self._requires_table(table)\\n table.set_column(column, values)\",\n \"def test_dummydb_add_data_to_table(self):\\n db = DummyDB()\\n columns = {\\n \\\"one\\\": int,\\n \\\"two\\\": str,\\n \\\"three\\\": bool,\\n }\\n db.create_table(\\\"new_table\\\", columns)\\n db.insert(\\\"new_table\\\", one=1, two=\\\"haunted\\\", three=True)\\n result = db.select(\\\"new_table\\\", one=1)\\n self.assertEqual(result[0]['two'], \\\"haunted\\\")\",\n \"def set_col( self, col ):\\n self.ix_col = col\",\n \"def add_col(self):\\r\\n reader = csv.reader(open(self.in_csvfile, newline=''))\\r\\n rows = list(reader)\\r\\n rows[0].append(self.col_name)\\r\\n for i in range(1, len(rows)):\\r\\n rows[i].append(self.cell_filler(rows[i]))\\r\\n writer = csv.writer(open(self.out_csvfile, 'w', newline=''))\\r\\n writer.writerows(rows)\",\n \"def AddColumnInfo(self, colInfo):\\r\\n \\r\\n self._columns.append(colInfo)\\r\\n self._total_col_width += colInfo.GetWidth()\\r\\n self._owner.AdjustMyScrollbars()\\r\\n self._owner._dirty = True\",\n \"def insert(self, sql):\\n try:\\n # Execute the SQL command\\n self.cursor.execute(sql)\\n # Commit your changes in the database\\n self.db.commit()\\n except:\\n # Rollback in case there is any error\\n self.db.rollback()\",\n \"def append_column(self, column: [str]) -> None:\\n self.content.append(column)\",\n \"def add_column(self, column, replace=False, **kwargs):\\n if not isinstance(column, Column):\\n raise ValueError('Invalid value. Must be column')\\n\\n if not hasattr(column, 'id'):\\n raise Exception('No id at column')\\n\\n # We return silently if the column already exists\\n if str(column) in self._columns and replace is False:\\n # raise Exception('Column \\\"{0}\\\" already exists'.format(str(column)))\\n return\\n\\n self._columns[str(column)] = column\",\n \"def insert_after(self, text, line, col):\\n col = self.canonicalize_column_index(line, col)\\n col_off = self.col_offs[line]\\n adj_col = col_off.get_rewritten_pos(col)\\n theline = self.lines[line]\\n self.lines[line] = theline[:adj_col] + text + theline[adj_col:]\\n col_off.insert(col, len(text))\",\n \"def insert (self, column, figure):\\r\\n\\t\\tc = self.board[column]\\r\\n\\t\\tif c[0] != NONE:\\r\\n\\t\\t\\traise Exception('Column is full')\\r\\n\\r\\n\\t\\ti = -1\\r\\n\\t\\twhile c[i] != NONE:\\r\\n\\t\\t\\ti -= 1\\r\\n\\t\\tc[i] = figure\\r\\n\\r\\n\\t\\tself.checkForWin()\",\n \"def upgrade_alter_table(self, db, tablename, colname, coltype):\\n try:\\n cursor = db.cursor()\\n cursor.execute(\\\"select %s from %s\\\" % (colname,tablename))\\n except Exception, e:\\n self.log.debug(\\\"upgrade_alter_table: %s\\\", e)\\n cursor = db.cursor()\\n alter = \\\"ALTER TABLE %s add column %s %s\\\" % (tablename, colname,\\n coltype)\\n cursor.execute(alter)\",\n \"def transfer_data(self, column_in, column_out):\\n self.open_msfile()\\n data_in = self.read_col(column_in)\\n self.open_msfile(nomodify=False)\\n self.tb.putcol(column_out, data_in)\\n self.close_msfile()\",\n \"def insert(self, data):\\r\\n pass\",\n \"def set_column(self,column):\\n\\t\\tif ( not self.validate(1,column)):\\n\\t\\t\\treturn\\n\\t\\tself.Grid[column] = 0xff\",\n \"def add_column(self, pos, char='-', new_label=None):\\n MutableAlignment.add_column(self, pos, char)\\n if new_label == \\\"MAX\\\":\\n self._col_labels.insert(pos, max(self._col_labels) + 1)\\n elif new_label == \\\"INC_LAST\\\":\\n self._col_labels.append(max(self._col_labels) + 1)\\n elif new_label == \\\"RESET\\\":\\n self._reset_col_names()\\n else:\\n self._col_labels.insert(pos, new_label)\",\n \"def new_column( self, delta = 1, ):\\n self.ix_row = 0\\n self.ix_col += delta\",\n \"def row_insert(self, to_insert : LinkedListNode, node_left : LinkedListNode):\\r\\n self.attach_columns([node_left], [to_insert])\",\n \"def add_field(self, field_name, field_type):\\n field_name = field_name.replace('\\\"','')\\n if field_type == 'keyword':\\n query = \\\"\\\"\\\"insert or ignore into keywords\\n (_keyword) values (\\\"%s\\\")\\\"\\\"\\\" % field_name\\n else:\\n query = 'alter table files add column \\\"%s\\\" %s' % (\\n field_name, field_type)\\n self.connection.execute(query)\\n self.connection.commit()\\n self.init_fields()\",\n \"def _add_column(self, column):\\n if column is None:\\n column = len(self._columns)\\n\\n if column in self._columns:\\n raise ValueError(f\\\"Duplicate column name: {column}\\\")\\n\\n if isinstance(column, int):\\n assert column >= len(self._columns)\\n for empty in range(len(self._columns), column):\\n self._add_column(empty)\\n\\n self._columns.append(column)\\n for idx in self.index:\\n row = self._data[idx]\\n row.append(None)\\n\\n return len(self._columns) - 1\",\n \"def addStudyActualColumn(self, study_id, column_name, table_name):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n con.cursor().callproc('qiime_assets.add_study_actual_column', [study_id, column_name, table_name])\\n except Exception, e: \\n raise Exception('Exception caught in addStudyActualColumns(): %s.\\\\nThe error is: %s' % (type(e), e))\",\n \"def update_column(conn, table, column, pk_column, pk, value) -> None:\\n with conn.cursor() as curs:\\n query = sql.SQL('UPDATE {} SET {} = %s WHERE {} = %s').format(sql.Identifier(table), sql.Identifier(column),\\n sql.Identifier(pk_column))\\n values = (value, pk)\\n curs.execute(query, values)\\n conn.commit()\",\n \"def augment_column(self, col: pd.Series,) -> pd.Series:\",\n \"def insert_values():\\n pass\",\n \"def add_new_column(dataframe, column_name):\\r\\n dataframe[column_name] = \\\"\\\"\\r\\n return dataframe\",\n \"def datetime(self, column, nullable=False):\\n self._last_column = self.table.add_column(column, \\\"datetime\\\", nullable=nullable)\\n return self\",\n \"def alter_column(self, table_name, name, field, explicit_name=True):\\r\\n # Get the column's SQL\\r\\n field.set_attributes_from_name(name)\\r\\n if not explicit_name:\\r\\n name = field.column\\r\\n sql = self.column_sql(table_name, name, field)\\r\\n # Remake the table correctly\\r\\n self._remake_table(table_name, altered={name: sql})\",\n \"def _insert_into_new_columns(self, commit, mapping_index):\\n for i in range(self.num_new_columns):\\n if self.new_columns[i].commit == commit:\\n self.mapping[mapping_index] = i\\n return mapping_index + 2\\n\\n # This commit isn't already in new_columns. Add it.\\n column = Column(commit, self._find_commit_color(commit))\\n self.new_columns[self.num_new_columns] = column\\n self.mapping[mapping_index] = self.num_new_columns\\n self.num_new_columns += 1\\n return mapping_index + 2\",\n \"def add_column(self, name, display=None):\\n column = column_v2()\\n column.data.name = name\\n column.display.name = display\\n self.columns.append(column)\\n self.column_length=len(self.columns)\\n self.update_ordinals()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6773","0.65841776","0.64992654","0.6474949","0.6455139","0.64373386","0.6368149","0.6303153","0.629054","0.6239281","0.6229999","0.622003","0.6205193","0.6202118","0.6199418","0.6196598","0.6169299","0.6163966","0.613079","0.60933846","0.60929984","0.6081151","0.6055493","0.60359025","0.59919715","0.59901536","0.5931063","0.592207","0.5881164","0.58758914","0.58657616","0.5856725","0.5833709","0.5829341","0.5818589","0.5784372","0.57779795","0.5775562","0.5761633","0.5746925","0.57399875","0.5710831","0.56589913","0.5655886","0.5653513","0.5631186","0.56180423","0.5609896","0.56021214","0.55898255","0.55865705","0.55679643","0.55674714","0.5556858","0.5554865","0.5544665","0.5530175","0.5505537","0.54844064","0.54808116","0.54756075","0.5474269","0.54624087","0.54438233","0.5435506","0.54281986","0.54277176","0.5427208","0.5419681","0.54191524","0.54031736","0.5393299","0.53931564","0.5389707","0.53782916","0.53771967","0.5372064","0.53638047","0.53553796","0.535385","0.5351202","0.53440624","0.53408426","0.53378016","0.5335918","0.5322666","0.53130525","0.53054917","0.5291952","0.52802706","0.5264536","0.5249069","0.5248277","0.5247614","0.5243107","0.5240806","0.52357256","0.5227911","0.522759","0.51962996"],"string":"[\n \"0.6773\",\n \"0.65841776\",\n \"0.64992654\",\n \"0.6474949\",\n \"0.6455139\",\n \"0.64373386\",\n \"0.6368149\",\n \"0.6303153\",\n \"0.629054\",\n \"0.6239281\",\n \"0.6229999\",\n \"0.622003\",\n \"0.6205193\",\n \"0.6202118\",\n \"0.6199418\",\n \"0.6196598\",\n \"0.6169299\",\n \"0.6163966\",\n \"0.613079\",\n \"0.60933846\",\n \"0.60929984\",\n \"0.6081151\",\n \"0.6055493\",\n \"0.60359025\",\n \"0.59919715\",\n \"0.59901536\",\n \"0.5931063\",\n \"0.592207\",\n \"0.5881164\",\n \"0.58758914\",\n \"0.58657616\",\n \"0.5856725\",\n \"0.5833709\",\n \"0.5829341\",\n \"0.5818589\",\n \"0.5784372\",\n \"0.57779795\",\n \"0.5775562\",\n \"0.5761633\",\n \"0.5746925\",\n \"0.57399875\",\n \"0.5710831\",\n \"0.56589913\",\n \"0.5655886\",\n \"0.5653513\",\n \"0.5631186\",\n \"0.56180423\",\n \"0.5609896\",\n \"0.56021214\",\n \"0.55898255\",\n \"0.55865705\",\n \"0.55679643\",\n \"0.55674714\",\n \"0.5556858\",\n \"0.5554865\",\n \"0.5544665\",\n \"0.5530175\",\n \"0.5505537\",\n \"0.54844064\",\n \"0.54808116\",\n \"0.54756075\",\n \"0.5474269\",\n \"0.54624087\",\n \"0.54438233\",\n \"0.5435506\",\n \"0.54281986\",\n \"0.54277176\",\n \"0.5427208\",\n \"0.5419681\",\n \"0.54191524\",\n \"0.54031736\",\n \"0.5393299\",\n \"0.53931564\",\n \"0.5389707\",\n \"0.53782916\",\n \"0.53771967\",\n \"0.5372064\",\n \"0.53638047\",\n \"0.53553796\",\n \"0.535385\",\n \"0.5351202\",\n \"0.53440624\",\n \"0.53408426\",\n \"0.53378016\",\n \"0.5335918\",\n \"0.5322666\",\n \"0.53130525\",\n \"0.53054917\",\n \"0.5291952\",\n \"0.52802706\",\n \"0.5264536\",\n \"0.5249069\",\n \"0.5248277\",\n \"0.5247614\",\n \"0.5243107\",\n \"0.5240806\",\n \"0.52357256\",\n \"0.5227911\",\n \"0.522759\",\n \"0.51962996\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76917046"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14876,"cells":{"query":{"kind":"string","value":"Get values for keys"},"document":{"kind":"string","value":"def mget(self, keys: List[K]) -> List[Optional[V]]:\n raise NotImplementedError('mget must be reimplemented in concrete implementation')"},"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_key_values(self):\n return self.key_values","def values(self):\n with self.__plock:\n return map(self.get, self._keys)","def values(self):\n return [self[k] for k in self.keys()]","def values(self):\n return [self[key] for key in self.keys()]","def values(self):\n return [self[key] for key in self.keys()]","def values(self):\n return [self[key] for key in self.keys()]","def values(self):\n return [self[name] for name in self.keys()]","def getall(self, key):\n return self.values.get(key, [])","def values(self, *args, **kwargs):\n return [ self._get(doc, *args, **kwargs) for doc in self.keys(*args, **kwargs) ]","def keyValues(self): # real signature unknown; restored from __doc__\n return []","def getitems(self):\n return {k:self.get(k) for k in self.keys}","def values(self):\n x = []\n for k in list(self.keys()):\n x.append(self[k])\n return x","def values(self):\r\n return [self[k] for k in self]","def values(self):\n values = []\n for key in self.keys():\n values.append(self[key])\n return values","def valsForKeys(h, *keys):\n return [h[k] for k in keys]","def items(self):\n return ((key, value) for (key, value) in zip(self.__keys, self.__vals))","def values(self):\n return self.d.keys()","def values(self):\n return [kvp.value for kvp in self.keyvaluepair_set.all()]","def get_many(self, *keys):\n key_x_value = self.get_dict(*keys)\n return [key_x_value[key] for key in keys]","def values(\n self, *keys: _TResultKey\n ) -> t.List[t.List[t.Any]]:\n return [record.values(*keys) for record in self]","def get_cursor_values(self, keys: Set[str]) -> Mapping[str, str]:","def _key_vals(dict_):\n return [(key, val) for key, val in dict_.iteritems()]","def items(self):\n return list(zip(self.keys(), self.values()))","def items(self):\n return list(zip(self.keys(), self.values()))","def get_dictionary_values(self,dictionary):\r\n return [dictionary[k] for k in self.get_dictionary_keys(dictionary)]","def multiget(self, keys):\n return self.sp.multiget(keys)","def values(self, *keys: _K) -> t.List[t.Any]: # type: ignore[override]\n if keys:\n d: t.List[t.Any] = []\n for key in keys:\n try:\n i = self.index(key)\n except KeyError:\n d.append(None)\n else:\n d.append(self[i])\n return d\n return list(self)","def items(self):\n return [(kvp.key, kvp.value) for kvp in self.keyvaluepair_set.all()]","def items(self):\n return zip(self._keys, self._values)","def list_values(key):\n return meta.list_values(key=key)","def items(self):\n return [(k, self[k]) for k in self.keys()]","def get_items(self, value, key=None):\n if key is None:\n return self.dicts(value)\n else:\n items = self.dicts(value)\n return [item[key] for item in items]","def values(self):\n return [ self[x] for x in self ]","def items(self):\n return [(key, self[key]) for key in self.keys()]","def items(self):\n return [(key, self[key]) for key in self.keys()]","def values(self):\n # Loop through all buckets\n # Collect all values in each bucket\n values_list = []\n\n for linked_list in self.buckets:\n for key_value_tuple in linked_list.items():\n values_list.append(key_value_tuple[1])\n\n return values_list","def values(self):\n # TODO: Collect all values in each of the buckets\n all_values = [] # Will store all the key\n\n for bucket in self.buckets:\n for value in bucket:\n if value is not None:\n all_values.append(value[1])\n return all_values","def items(self, *args, **kwargs):\n return [ (key, self._get(key, *args, **kwargs),) for key in self.keys(*args, **kwargs) ]","def obtain(self, key):\n if key in self:\n vals = self[key]\n else:\n vals = []\n dict.__setitem__(self, key, vals)\n return vals","def get_values(self) -> list:\r\n values = []\r\n for key, value in self._items:\r\n values.append(value)\r\n return values","def items(self):\n with self.__plock:\n return map(lambda key: (key, self[key]), self._keys)","def keys(self):\r\n return [key for key, value in self.iteritems()]","def get_for_key(self, key) -> list:\n return [res[key] for res in self.list]","def keys():","def values(self):\n return [_ for _ in self._dict.values()]","def items(self):\n x = []\n for k in list(self.keys()):\n x.append((k, self[k]))\n return x","def _get_keys(self, listOfKeys):\n return self._keys","def values(self, key=None, lo=None, hi=None, reverse=None, max=None,\n include=False, txn=None, rec=None):\n return itertools.imap(ITEMGETTER_1,\n self.items(key, lo, hi, reverse, max, include, txn, rec))","def keys(self):\n return [key for key, value in self.items()]","def values():","def values(self, values=None):\n return [self[key] for key in self._sequence]","async def _multi_get(self, keys):\n values = []\n for value in await self.client.multi_get(*keys):\n if value is not None and self.encoding is not None:\n values.append(bytes.decode(value))\n else:\n values.append(value)\n return values","def read_keyValues():\n # Create the list of CIs from our data\n ci = db.session.query(CI).order_by(CI.id).all()\n app.logger.debug(pformat(ci))\n # Serialize the data for the response\n ci_schema = CISchema(many=True)\n data = ci_schema.dump(ci)\n keyValues = []\n for d in data:\n keyValuePair = {}\n keyValuePair[\"key\"] = d.get(\"id\")\n keyValuePair[\"value\"] = d.get(\"value\")\n keyValues.append(keyValuePair)\n print(keyValues)\n return keyValues","def get_keys(self) -> Dict[str, str]:\n return self.http.get(self.config.paths.keys)","def keys(self):\r\n return [k for k in self]","def get_keys(self):\r\n return self._keys","async def keys(self) -> Iterable[str]:","def get_dictionary_items(self,dictionary):\r\n ret = []\r\n for key in self.get_dictionary_keys(dictionary):\r\n ret.extend((key,dictionary[key]))\r\n return ret","def items(self):\r\n return [(k, self[k]) for k in self]","def keys(self):\n return [kvp.key for kvp in self.keyvaluepair_set.all()]","def items(self):\r\n L = []\r\n for key, value in self.data.items():\r\n o = key()\r\n if o is not None:\r\n L.append((o, value))\r\n return L","def items(self):\r\n L = []\r\n for key, value in self.data.items():\r\n o = key()\r\n if o is not None:\r\n L.append((o, value))\r\n return L","def getAllValues(self, keyName):\n self._db._c.execute(\"SELECT \" + keyName + \" FROM \" + self.tableName)\n\n return [ col[0] for col in self._db._c.fetchall() ]","def itervalues(self, key=None):\n if key != None:\n vals = self.get(key)\n if vals != None:\n for val in vals:\n yield val\n else:\n for key in self.iterkeys():\n vals = self.get(key)\n for val in vals:\n yield val","def values(self):\n for key in self.metadb.values():\n yield key, self.datadb[key]","def getlist(self, key):\n try:\n return dict.__getitem__(self, key)\n except KeyError:\n return []","def get_norm_key_values(self, board):\n return self.key_values","async def values(self) -> Iterable[ResponseOrKey]:","def getkeys(self):\n return list(self.keys)","def valuerefs(self):\r\n return self.data.values()","def itervalues(self, *args, **kwargs):\n for key in self.iterkeys():\n yield self._get(key, *args, **kwargs)","def multiget(self, keys):\n result = {}\n for key in keys:\n result[key] = self.get(key)\n return result","def key_dict_values (self):\r\n\r\n if self.using_database:\r\n value_tuple = (notebookname,)\r\n db_cursor.execute(\"SELECT note_index \"\r\n +\"FROM keys_to_indexes\"\r\n +\" WHERE notebook=?;\",\r\n value_tuple)\r\n\r\n fetched = db_cursor.fetchall()\r\n if fetched:\r\n return {index[0].strip() for index in fetched}\r\n return set()\r\n\r\n return self.key_dict.values()","async def get_keys(self):\n return self.dict.keys()","def get_values(self, ckey):\n for next_key, item in yield_obj(self, ckey):\n if isdictinstance(item):\n for final, elem in yield_obj(item, next_key):\n if isdictinstance(elem) and elem.has_key(final):\n yield elem[final]\n else:\n yield elem\n elif isinstance(item, list) or isinstance(item, GeneratorType):\n for final, elem in item:\n for last, att in yield_obj(elem, final):\n if isdictinstance(att) and att.has_key(last):\n yield att[last]\n else:\n yield att","def getValues(self):\n return self.__get('values')","def collect(self, *keys):\n items = []\n for key in keys:\n if key.endswith(b\"*\"):\n key, explode = key[:-1], True\n else:\n explode = False\n if b\":\" in key:\n key, max_length = key.partition(b\":\")[0::2]\n max_length = int(max_length)\n else:\n max_length = None\n value = self.values.get(key)\n if isinstance(value, dict):\n if not value:\n items.append((key, None))\n elif explode:\n items.extend((key, _) for _ in value.items())\n else:\n items.append((key, value))\n elif isinstance(value, (tuple, list)):\n if explode:\n items.extend((key, _) for _ in value)\n else:\n items.append((key, list(value)))\n elif max_length is not None:\n items.append((key, value[:max_length]))\n else:\n items.append((key, value))\n return [(key, value) for key, value in items if value is not None]","def itervalues(self):\n for key in self:\n yield self[key]","def getlist(self, key):\n try:\n vals = _dict_getitem(self, key.lower())\n except KeyError:\n return []\n else:\n if isinstance(vals, tuple):\n return [vals[1]]\n else:\n return vals[1:]","def values(self) -> Dict[str, Any]:\n pass","def itervalues(self):\n return iter(kvp.value for kvp in self.keyvaluepair_set.all())","def getByPath(self, keys):\n return reduce(operator.getitem, keys, self._data)","def keys(self):\n return _keys(self)","def keys(self):\n return _keys(self)","def values(cls):\n if cls._values is None:\n cls._values = tuple(getattr(cls, attr) for attr in cls.keys())\n return cls._values","def items(self):\n acc = []\n for k in self.keys():\n pm = self._maps[k]\n acc.append((k,pm))\n return acc","def keys(self) -> ir.ArrayValue:\n return ops.MapKeys(self).to_expr()","def keysAll():","def keys(self, key=None, lo=None, hi=None, reverse=None, max=None,\n include=False, txn=None, rec=None):\n return itertools.imap(ITEMGETTER_0,\n self.items(key, lo, hi, reverse, max, include, txn, rec))","def Keys(self) -> _n_1_t_4:","def dict_values(d):\n return list(d.values())","async def values(cls):\n result = []\n for key in await ProxyMethod.channel.call_remote(\n \"%s.values\" % (cls.__namespace__,),\n ):\n result.append(cls(key=key))\n return result","def values(self):\n return self[\"values\"]","def values(self):\n return self[\"values\"]","def items(self, *keys):\n if keys:\n d = []\n for key in keys:\n try:\n i = self.index(key)\n except KeyError:\n d.append((key, None))\n else:\n d.append((self.__keys[i], self[i]))\n return d\n return list((self.__keys[i], self._super_getitem_single(i))\n for i in range(len(self)))","def keys(self):\n return list(self.token2id.values())","def keys(self, installer_context):\n return self.spec.keys(self.data, installer_context)","def items(self) -> tuple[tuple[Any, Any], ...]: # type: ignore\n return tuple(zip(self.keys(), self.values()))","def get_multi_values(site_name, keys, _current_parser=None):\n return {site_name: {key: get_value(site_name, key, _current_parser) for key in keys}}","def keys(self):\n return self.keys"],"string":"[\n \"def get_key_values(self):\\n return self.key_values\",\n \"def values(self):\\n with self.__plock:\\n return map(self.get, self._keys)\",\n \"def values(self):\\n return [self[k] for k in self.keys()]\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def values(self):\\n return [self[name] for name in self.keys()]\",\n \"def getall(self, key):\\n return self.values.get(key, [])\",\n \"def values(self, *args, **kwargs):\\n return [ self._get(doc, *args, **kwargs) for doc in self.keys(*args, **kwargs) ]\",\n \"def keyValues(self): # real signature unknown; restored from __doc__\\n return []\",\n \"def getitems(self):\\n return {k:self.get(k) for k in self.keys}\",\n \"def values(self):\\n x = []\\n for k in list(self.keys()):\\n x.append(self[k])\\n return x\",\n \"def values(self):\\r\\n return [self[k] for k in self]\",\n \"def values(self):\\n values = []\\n for key in self.keys():\\n values.append(self[key])\\n return values\",\n \"def valsForKeys(h, *keys):\\n return [h[k] for k in keys]\",\n \"def items(self):\\n return ((key, value) for (key, value) in zip(self.__keys, self.__vals))\",\n \"def values(self):\\n return self.d.keys()\",\n \"def values(self):\\n return [kvp.value for kvp in self.keyvaluepair_set.all()]\",\n \"def get_many(self, *keys):\\n key_x_value = self.get_dict(*keys)\\n return [key_x_value[key] for key in keys]\",\n \"def values(\\n self, *keys: _TResultKey\\n ) -> t.List[t.List[t.Any]]:\\n return [record.values(*keys) for record in self]\",\n \"def get_cursor_values(self, keys: Set[str]) -> Mapping[str, str]:\",\n \"def _key_vals(dict_):\\n return [(key, val) for key, val in dict_.iteritems()]\",\n \"def items(self):\\n return list(zip(self.keys(), self.values()))\",\n \"def items(self):\\n return list(zip(self.keys(), self.values()))\",\n \"def get_dictionary_values(self,dictionary):\\r\\n return [dictionary[k] for k in self.get_dictionary_keys(dictionary)]\",\n \"def multiget(self, keys):\\n return self.sp.multiget(keys)\",\n \"def values(self, *keys: _K) -> t.List[t.Any]: # type: ignore[override]\\n if keys:\\n d: t.List[t.Any] = []\\n for key in keys:\\n try:\\n i = self.index(key)\\n except KeyError:\\n d.append(None)\\n else:\\n d.append(self[i])\\n return d\\n return list(self)\",\n \"def items(self):\\n return [(kvp.key, kvp.value) for kvp in self.keyvaluepair_set.all()]\",\n \"def items(self):\\n return zip(self._keys, self._values)\",\n \"def list_values(key):\\n return meta.list_values(key=key)\",\n \"def items(self):\\n return [(k, self[k]) for k in self.keys()]\",\n \"def get_items(self, value, key=None):\\n if key is None:\\n return self.dicts(value)\\n else:\\n items = self.dicts(value)\\n return [item[key] for item in items]\",\n \"def values(self):\\n return [ self[x] for x in self ]\",\n \"def items(self):\\n return [(key, self[key]) for key in self.keys()]\",\n \"def items(self):\\n return [(key, self[key]) for key in self.keys()]\",\n \"def values(self):\\n # Loop through all buckets\\n # Collect all values in each bucket\\n values_list = []\\n\\n for linked_list in self.buckets:\\n for key_value_tuple in linked_list.items():\\n values_list.append(key_value_tuple[1])\\n\\n return values_list\",\n \"def values(self):\\n # TODO: Collect all values in each of the buckets\\n all_values = [] # Will store all the key\\n\\n for bucket in self.buckets:\\n for value in bucket:\\n if value is not None:\\n all_values.append(value[1])\\n return all_values\",\n \"def items(self, *args, **kwargs):\\n return [ (key, self._get(key, *args, **kwargs),) for key in self.keys(*args, **kwargs) ]\",\n \"def obtain(self, key):\\n if key in self:\\n vals = self[key]\\n else:\\n vals = []\\n dict.__setitem__(self, key, vals)\\n return vals\",\n \"def get_values(self) -> list:\\r\\n values = []\\r\\n for key, value in self._items:\\r\\n values.append(value)\\r\\n return values\",\n \"def items(self):\\n with self.__plock:\\n return map(lambda key: (key, self[key]), self._keys)\",\n \"def keys(self):\\r\\n return [key for key, value in self.iteritems()]\",\n \"def get_for_key(self, key) -> list:\\n return [res[key] for res in self.list]\",\n \"def keys():\",\n \"def values(self):\\n return [_ for _ in self._dict.values()]\",\n \"def items(self):\\n x = []\\n for k in list(self.keys()):\\n x.append((k, self[k]))\\n return x\",\n \"def _get_keys(self, listOfKeys):\\n return self._keys\",\n \"def values(self, key=None, lo=None, hi=None, reverse=None, max=None,\\n include=False, txn=None, rec=None):\\n return itertools.imap(ITEMGETTER_1,\\n self.items(key, lo, hi, reverse, max, include, txn, rec))\",\n \"def keys(self):\\n return [key for key, value in self.items()]\",\n \"def values():\",\n \"def values(self, values=None):\\n return [self[key] for key in self._sequence]\",\n \"async def _multi_get(self, keys):\\n values = []\\n for value in await self.client.multi_get(*keys):\\n if value is not None and self.encoding is not None:\\n values.append(bytes.decode(value))\\n else:\\n values.append(value)\\n return values\",\n \"def read_keyValues():\\n # Create the list of CIs from our data\\n ci = db.session.query(CI).order_by(CI.id).all()\\n app.logger.debug(pformat(ci))\\n # Serialize the data for the response\\n ci_schema = CISchema(many=True)\\n data = ci_schema.dump(ci)\\n keyValues = []\\n for d in data:\\n keyValuePair = {}\\n keyValuePair[\\\"key\\\"] = d.get(\\\"id\\\")\\n keyValuePair[\\\"value\\\"] = d.get(\\\"value\\\")\\n keyValues.append(keyValuePair)\\n print(keyValues)\\n return keyValues\",\n \"def get_keys(self) -> Dict[str, str]:\\n return self.http.get(self.config.paths.keys)\",\n \"def keys(self):\\r\\n return [k for k in self]\",\n \"def get_keys(self):\\r\\n return self._keys\",\n \"async def keys(self) -> Iterable[str]:\",\n \"def get_dictionary_items(self,dictionary):\\r\\n ret = []\\r\\n for key in self.get_dictionary_keys(dictionary):\\r\\n ret.extend((key,dictionary[key]))\\r\\n return ret\",\n \"def items(self):\\r\\n return [(k, self[k]) for k in self]\",\n \"def keys(self):\\n return [kvp.key for kvp in self.keyvaluepair_set.all()]\",\n \"def items(self):\\r\\n L = []\\r\\n for key, value in self.data.items():\\r\\n o = key()\\r\\n if o is not None:\\r\\n L.append((o, value))\\r\\n return L\",\n \"def items(self):\\r\\n L = []\\r\\n for key, value in self.data.items():\\r\\n o = key()\\r\\n if o is not None:\\r\\n L.append((o, value))\\r\\n return L\",\n \"def getAllValues(self, keyName):\\n self._db._c.execute(\\\"SELECT \\\" + keyName + \\\" FROM \\\" + self.tableName)\\n\\n return [ col[0] for col in self._db._c.fetchall() ]\",\n \"def itervalues(self, key=None):\\n if key != None:\\n vals = self.get(key)\\n if vals != None:\\n for val in vals:\\n yield val\\n else:\\n for key in self.iterkeys():\\n vals = self.get(key)\\n for val in vals:\\n yield val\",\n \"def values(self):\\n for key in self.metadb.values():\\n yield key, self.datadb[key]\",\n \"def getlist(self, key):\\n try:\\n return dict.__getitem__(self, key)\\n except KeyError:\\n return []\",\n \"def get_norm_key_values(self, board):\\n return self.key_values\",\n \"async def values(self) -> Iterable[ResponseOrKey]:\",\n \"def getkeys(self):\\n return list(self.keys)\",\n \"def valuerefs(self):\\r\\n return self.data.values()\",\n \"def itervalues(self, *args, **kwargs):\\n for key in self.iterkeys():\\n yield self._get(key, *args, **kwargs)\",\n \"def multiget(self, keys):\\n result = {}\\n for key in keys:\\n result[key] = self.get(key)\\n return result\",\n \"def key_dict_values (self):\\r\\n\\r\\n if self.using_database:\\r\\n value_tuple = (notebookname,)\\r\\n db_cursor.execute(\\\"SELECT note_index \\\"\\r\\n +\\\"FROM keys_to_indexes\\\"\\r\\n +\\\" WHERE notebook=?;\\\",\\r\\n value_tuple)\\r\\n\\r\\n fetched = db_cursor.fetchall()\\r\\n if fetched:\\r\\n return {index[0].strip() for index in fetched}\\r\\n return set()\\r\\n\\r\\n return self.key_dict.values()\",\n \"async def get_keys(self):\\n return self.dict.keys()\",\n \"def get_values(self, ckey):\\n for next_key, item in yield_obj(self, ckey):\\n if isdictinstance(item):\\n for final, elem in yield_obj(item, next_key):\\n if isdictinstance(elem) and elem.has_key(final):\\n yield elem[final]\\n else:\\n yield elem\\n elif isinstance(item, list) or isinstance(item, GeneratorType):\\n for final, elem in item:\\n for last, att in yield_obj(elem, final):\\n if isdictinstance(att) and att.has_key(last):\\n yield att[last]\\n else:\\n yield att\",\n \"def getValues(self):\\n return self.__get('values')\",\n \"def collect(self, *keys):\\n items = []\\n for key in keys:\\n if key.endswith(b\\\"*\\\"):\\n key, explode = key[:-1], True\\n else:\\n explode = False\\n if b\\\":\\\" in key:\\n key, max_length = key.partition(b\\\":\\\")[0::2]\\n max_length = int(max_length)\\n else:\\n max_length = None\\n value = self.values.get(key)\\n if isinstance(value, dict):\\n if not value:\\n items.append((key, None))\\n elif explode:\\n items.extend((key, _) for _ in value.items())\\n else:\\n items.append((key, value))\\n elif isinstance(value, (tuple, list)):\\n if explode:\\n items.extend((key, _) for _ in value)\\n else:\\n items.append((key, list(value)))\\n elif max_length is not None:\\n items.append((key, value[:max_length]))\\n else:\\n items.append((key, value))\\n return [(key, value) for key, value in items if value is not None]\",\n \"def itervalues(self):\\n for key in self:\\n yield self[key]\",\n \"def getlist(self, key):\\n try:\\n vals = _dict_getitem(self, key.lower())\\n except KeyError:\\n return []\\n else:\\n if isinstance(vals, tuple):\\n return [vals[1]]\\n else:\\n return vals[1:]\",\n \"def values(self) -> Dict[str, Any]:\\n pass\",\n \"def itervalues(self):\\n return iter(kvp.value for kvp in self.keyvaluepair_set.all())\",\n \"def getByPath(self, keys):\\n return reduce(operator.getitem, keys, self._data)\",\n \"def keys(self):\\n return _keys(self)\",\n \"def keys(self):\\n return _keys(self)\",\n \"def values(cls):\\n if cls._values is None:\\n cls._values = tuple(getattr(cls, attr) for attr in cls.keys())\\n return cls._values\",\n \"def items(self):\\n acc = []\\n for k in self.keys():\\n pm = self._maps[k]\\n acc.append((k,pm))\\n return acc\",\n \"def keys(self) -> ir.ArrayValue:\\n return ops.MapKeys(self).to_expr()\",\n \"def keysAll():\",\n \"def keys(self, key=None, lo=None, hi=None, reverse=None, max=None,\\n include=False, txn=None, rec=None):\\n return itertools.imap(ITEMGETTER_0,\\n self.items(key, lo, hi, reverse, max, include, txn, rec))\",\n \"def Keys(self) -> _n_1_t_4:\",\n \"def dict_values(d):\\n return list(d.values())\",\n \"async def values(cls):\\n result = []\\n for key in await ProxyMethod.channel.call_remote(\\n \\\"%s.values\\\" % (cls.__namespace__,),\\n ):\\n result.append(cls(key=key))\\n return result\",\n \"def values(self):\\n return self[\\\"values\\\"]\",\n \"def values(self):\\n return self[\\\"values\\\"]\",\n \"def items(self, *keys):\\n if keys:\\n d = []\\n for key in keys:\\n try:\\n i = self.index(key)\\n except KeyError:\\n d.append((key, None))\\n else:\\n d.append((self.__keys[i], self[i]))\\n return d\\n return list((self.__keys[i], self._super_getitem_single(i))\\n for i in range(len(self)))\",\n \"def keys(self):\\n return list(self.token2id.values())\",\n \"def keys(self, installer_context):\\n return self.spec.keys(self.data, installer_context)\",\n \"def items(self) -> tuple[tuple[Any, Any], ...]: # type: ignore\\n return tuple(zip(self.keys(), self.values()))\",\n \"def get_multi_values(site_name, keys, _current_parser=None):\\n return {site_name: {key: get_value(site_name, key, _current_parser) for key in keys}}\",\n \"def keys(self):\\n return self.keys\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78560966","0.7809564","0.7629101","0.76030433","0.76030433","0.76030433","0.75565445","0.7534844","0.75304735","0.7513847","0.74225706","0.73467046","0.72960025","0.7254402","0.7246637","0.71887136","0.70794696","0.7065934","0.6987683","0.69494283","0.6942988","0.6925193","0.6921116","0.6921116","0.68971395","0.6884749","0.68643177","0.6851204","0.6831352","0.6824089","0.68004936","0.6776986","0.67650104","0.6751484","0.6751484","0.67084974","0.67026925","0.67013144","0.66988117","0.66950595","0.6649915","0.663744","0.66226304","0.661625","0.65910095","0.65902376","0.6590174","0.65851146","0.6567864","0.65675735","0.6543684","0.65124464","0.6472351","0.64627516","0.64473814","0.6436263","0.64196295","0.6419472","0.6410377","0.64061207","0.64008796","0.64008796","0.6389831","0.6389107","0.6376249","0.63646686","0.635905","0.63577265","0.6351017","0.63487625","0.6347494","0.6338","0.6337458","0.6324117","0.63229364","0.6322733","0.631857","0.6317678","0.6294077","0.62873614","0.62689227","0.6264965","0.62448233","0.62448233","0.62408775","0.6236584","0.6236434","0.6235009","0.6234189","0.62341493","0.6213993","0.621047","0.6204516","0.6204516","0.6189985","0.6187333","0.61866724","0.6186162","0.61846876","0.61814475"],"string":"[\n \"0.78560966\",\n \"0.7809564\",\n \"0.7629101\",\n \"0.76030433\",\n \"0.76030433\",\n \"0.76030433\",\n \"0.75565445\",\n \"0.7534844\",\n \"0.75304735\",\n \"0.7513847\",\n \"0.74225706\",\n \"0.73467046\",\n \"0.72960025\",\n \"0.7254402\",\n \"0.7246637\",\n \"0.71887136\",\n \"0.70794696\",\n \"0.7065934\",\n \"0.6987683\",\n \"0.69494283\",\n \"0.6942988\",\n \"0.6925193\",\n \"0.6921116\",\n \"0.6921116\",\n \"0.68971395\",\n \"0.6884749\",\n \"0.68643177\",\n \"0.6851204\",\n \"0.6831352\",\n \"0.6824089\",\n \"0.68004936\",\n \"0.6776986\",\n \"0.67650104\",\n \"0.6751484\",\n \"0.6751484\",\n \"0.67084974\",\n \"0.67026925\",\n \"0.67013144\",\n \"0.66988117\",\n \"0.66950595\",\n \"0.6649915\",\n \"0.663744\",\n \"0.66226304\",\n \"0.661625\",\n \"0.65910095\",\n \"0.65902376\",\n \"0.6590174\",\n \"0.65851146\",\n \"0.6567864\",\n \"0.65675735\",\n \"0.6543684\",\n \"0.65124464\",\n \"0.6472351\",\n \"0.64627516\",\n \"0.64473814\",\n \"0.6436263\",\n \"0.64196295\",\n \"0.6419472\",\n \"0.6410377\",\n \"0.64061207\",\n \"0.64008796\",\n \"0.64008796\",\n \"0.6389831\",\n \"0.6389107\",\n \"0.6376249\",\n \"0.63646686\",\n \"0.635905\",\n \"0.63577265\",\n \"0.6351017\",\n \"0.63487625\",\n \"0.6347494\",\n \"0.6338\",\n \"0.6337458\",\n \"0.6324117\",\n \"0.63229364\",\n \"0.6322733\",\n \"0.631857\",\n \"0.6317678\",\n \"0.6294077\",\n \"0.62873614\",\n \"0.62689227\",\n \"0.6264965\",\n \"0.62448233\",\n \"0.62448233\",\n \"0.62408775\",\n \"0.6236584\",\n \"0.6236434\",\n \"0.6235009\",\n \"0.6234189\",\n \"0.62341493\",\n \"0.6213993\",\n \"0.621047\",\n \"0.6204516\",\n \"0.6204516\",\n \"0.6189985\",\n \"0.6187333\",\n \"0.61866724\",\n \"0.6186162\",\n \"0.61846876\",\n \"0.61814475\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62629557"},"document_rank":{"kind":"string","value":"82"}}},{"rowIdx":14877,"cells":{"query":{"kind":"string","value":"Get a single key"},"document":{"kind":"string","value":"def get(self, key: K) -> Optional[V]:\n return self.mget([key])[0]"},"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_key(self):\n return self._determine_key()","def key(key):\n return key","def get(self, key):\n result = self.search({\n \"field\": \"identity.key\",\n \"operator\": \"=\",\n \"value\": key})\n if len(result) > 1:\n raise SarasvatiException(\"Entity is not unique {}\".format(key))\n return result[0] if len(result) > 0 else None","def get_key(self):\n return self.key","def get_key(self):\n return self.key","def get(self, key):\n hash_key = key % self.key_space\n return self.hash_table[hash_key].get(key)","def GetKeyByPath(self, key_path):","def get_key(self, key_id):\r\n return self.sshkey.getObject(id=key_id)","def get(self, key, key_type=None):\n pass","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[str]:\n return pulumi.get(self, \"key\")","def getKey(self):\n\t\treturn self.key","def get(self, key):","def get(self, key):","def get(self, key):\n return self.execute_command(self.GET_CMD, key)","def GetKey(self, version_number):\n return self.dict[str(version_number)]","def getKeyObj(self,\n key,\n no = 0):\n keyword = key + \"___\" + str(no + 1)\n return self.__keyObjs[keyword]","def get_key(self) -> int:\n return self.key","def get_key(self, key):\n ret = None\n qkey = key.__qualname__\n ret = self.get(qkey)\n if not ret:\n # check all entries if qualname match\n for k in self:\n if k.__qualname__ == qkey:\n return self.get(k)\n return","def getKey(self):\n return self.key","def get(self, key):\n\t\treturn self.__get(key, key[1:])","def getKey(self):\n return self.key","def getKey( self, key ):\n if key in self.conf:\n return self.conf[key]\n else:\n return None","def getKeyValue(self,\n key,\n no = 0):\n keyword = key + \"___\" + str(no + 1)\n return self.__keyObjs[keyword].getValue()","def _get_key(args):\n\n input_key = args.input_key\n key = None\n if input_key:\n from pathlib import Path\n key_file = Path(input_key)\n if key_file.is_file():\n key = load_key(key_file)\n\n if not key:\n key = key_handler(args)\n\n return key","def get_key(dict, key):\n return dict.get(key, None)","def get(id):\n repo = KeyRepository(getDb())\n try:\n key = repo.findOne(id)\n except DBException:\n return {'message': 'Key id is invalid'}, 400\n\n if key == None:\n return {'message': 'Key has not been found'}, 404\n else:\n return base64.b64decode(key.publicKey)","def getKey(self):\n return self.__key","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key\")","def get(self, key):\n pass","def _get_doc_key(self, doc_id, key):\n cursor = self.connection.cursor()\n cursor.execute(\n \"SELECT {} FROM documents WHERE id = ?\".format(key),\n (normalize(doc_id),)\n )\n result = cursor.fetchone()\n cursor.close()\n return result if result is None else result[0]","def getKey(self, key):\n return self.BUCKET.get_key(key)","def get_key(self, object_id):\n try:\n info = self.storage.load(\"\", object_id)\n return info[\"object_key\"]\n except KeyError:\n return None","def _get_raw_key(self, key_id):","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")"],"string":"[\n \"def get_key(self):\\n return self._determine_key()\",\n \"def key(key):\\n return key\",\n \"def get(self, key):\\n result = self.search({\\n \\\"field\\\": \\\"identity.key\\\",\\n \\\"operator\\\": \\\"=\\\",\\n \\\"value\\\": key})\\n if len(result) > 1:\\n raise SarasvatiException(\\\"Entity is not unique {}\\\".format(key))\\n return result[0] if len(result) > 0 else None\",\n \"def get_key(self):\\n return self.key\",\n \"def get_key(self):\\n return self.key\",\n \"def get(self, key):\\n hash_key = key % self.key_space\\n return self.hash_table[hash_key].get(key)\",\n \"def GetKeyByPath(self, key_path):\",\n \"def get_key(self, key_id):\\r\\n return self.sshkey.getObject(id=key_id)\",\n \"def get(self, key, key_type=None):\\n pass\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[str]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def getKey(self):\\n\\t\\treturn self.key\",\n \"def get(self, key):\",\n \"def get(self, key):\",\n \"def get(self, key):\\n return self.execute_command(self.GET_CMD, key)\",\n \"def GetKey(self, version_number):\\n return self.dict[str(version_number)]\",\n \"def getKeyObj(self,\\n key,\\n no = 0):\\n keyword = key + \\\"___\\\" + str(no + 1)\\n return self.__keyObjs[keyword]\",\n \"def get_key(self) -> int:\\n return self.key\",\n \"def get_key(self, key):\\n ret = None\\n qkey = key.__qualname__\\n ret = self.get(qkey)\\n if not ret:\\n # check all entries if qualname match\\n for k in self:\\n if k.__qualname__ == qkey:\\n return self.get(k)\\n return\",\n \"def getKey(self):\\n return self.key\",\n \"def get(self, key):\\n\\t\\treturn self.__get(key, key[1:])\",\n \"def getKey(self):\\n return self.key\",\n \"def getKey( self, key ):\\n if key in self.conf:\\n return self.conf[key]\\n else:\\n return None\",\n \"def getKeyValue(self,\\n key,\\n no = 0):\\n keyword = key + \\\"___\\\" + str(no + 1)\\n return self.__keyObjs[keyword].getValue()\",\n \"def _get_key(args):\\n\\n input_key = args.input_key\\n key = None\\n if input_key:\\n from pathlib import Path\\n key_file = Path(input_key)\\n if key_file.is_file():\\n key = load_key(key_file)\\n\\n if not key:\\n key = key_handler(args)\\n\\n return key\",\n \"def get_key(dict, key):\\n return dict.get(key, None)\",\n \"def get(id):\\n repo = KeyRepository(getDb())\\n try:\\n key = repo.findOne(id)\\n except DBException:\\n return {'message': 'Key id is invalid'}, 400\\n\\n if key == None:\\n return {'message': 'Key has not been found'}, 404\\n else:\\n return base64.b64decode(key.publicKey)\",\n \"def getKey(self):\\n return self.__key\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def get(self, key):\\n pass\",\n \"def _get_doc_key(self, doc_id, key):\\n cursor = self.connection.cursor()\\n cursor.execute(\\n \\\"SELECT {} FROM documents WHERE id = ?\\\".format(key),\\n (normalize(doc_id),)\\n )\\n result = cursor.fetchone()\\n cursor.close()\\n return result if result is None else result[0]\",\n \"def getKey(self, key):\\n return self.BUCKET.get_key(key)\",\n \"def get_key(self, object_id):\\n try:\\n info = self.storage.load(\\\"\\\", object_id)\\n return info[\\\"object_key\\\"]\\n except KeyError:\\n return None\",\n \"def _get_raw_key(self, key_id):\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74487877","0.7393895","0.73517627","0.7345837","0.7345837","0.7293161","0.7262227","0.7217249","0.71878386","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7176885","0.7144434","0.7139841","0.7139841","0.7132704","0.7108802","0.71033293","0.70622724","0.70501256","0.70433307","0.7027999","0.7027659","0.70241463","0.70139956","0.70112675","0.7005769","0.6994888","0.6947176","0.694569","0.694569","0.694569","0.694569","0.694569","0.694569","0.694569","0.694569","0.694569","0.694569","0.694569","0.694569","0.6940307","0.6938663","0.6937281","0.6916362","0.6907817","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615","0.68992615"],"string":"[\n \"0.74487877\",\n \"0.7393895\",\n \"0.73517627\",\n \"0.7345837\",\n \"0.7345837\",\n \"0.7293161\",\n \"0.7262227\",\n \"0.7217249\",\n \"0.71878386\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7176885\",\n \"0.7144434\",\n \"0.7139841\",\n \"0.7139841\",\n \"0.7132704\",\n \"0.7108802\",\n \"0.71033293\",\n \"0.70622724\",\n \"0.70501256\",\n \"0.70433307\",\n \"0.7027999\",\n \"0.7027659\",\n \"0.70241463\",\n \"0.70139956\",\n \"0.70112675\",\n \"0.7005769\",\n \"0.6994888\",\n \"0.6947176\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.694569\",\n \"0.6940307\",\n \"0.6938663\",\n \"0.6937281\",\n \"0.6916362\",\n \"0.6907817\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\",\n \"0.68992615\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14878,"cells":{"query":{"kind":"string","value":"Get values for keys"},"document":{"kind":"string","value":"def mset(self, kvs: Mapping[K, V]) -> List[bool]:\n raise NotImplementedError('mset must be reimplemented in concrete implementation')"},"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_key_values(self):\n return self.key_values","def values(self):\n with self.__plock:\n return map(self.get, self._keys)","def values(self):\n return [self[k] for k in self.keys()]","def values(self):\n return [self[key] for key in self.keys()]","def values(self):\n return [self[key] for key in self.keys()]","def values(self):\n return [self[key] for key in self.keys()]","def values(self):\n return [self[name] for name in self.keys()]","def getall(self, key):\n return self.values.get(key, [])","def values(self, *args, **kwargs):\n return [ self._get(doc, *args, **kwargs) for doc in self.keys(*args, **kwargs) ]","def keyValues(self): # real signature unknown; restored from __doc__\n return []","def getitems(self):\n return {k:self.get(k) for k in self.keys}","def values(self):\n x = []\n for k in list(self.keys()):\n x.append(self[k])\n return x","def values(self):\r\n return [self[k] for k in self]","def values(self):\n values = []\n for key in self.keys():\n values.append(self[key])\n return values","def valsForKeys(h, *keys):\n return [h[k] for k in keys]","def items(self):\n return ((key, value) for (key, value) in zip(self.__keys, self.__vals))","def values(self):\n return self.d.keys()","def values(self):\n return [kvp.value for kvp in self.keyvaluepair_set.all()]","def get_many(self, *keys):\n key_x_value = self.get_dict(*keys)\n return [key_x_value[key] for key in keys]","def values(\n self, *keys: _TResultKey\n ) -> t.List[t.List[t.Any]]:\n return [record.values(*keys) for record in self]","def get_cursor_values(self, keys: Set[str]) -> Mapping[str, str]:","def _key_vals(dict_):\n return [(key, val) for key, val in dict_.iteritems()]","def items(self):\n return list(zip(self.keys(), self.values()))","def items(self):\n return list(zip(self.keys(), self.values()))","def get_dictionary_values(self,dictionary):\r\n return [dictionary[k] for k in self.get_dictionary_keys(dictionary)]","def multiget(self, keys):\n return self.sp.multiget(keys)","def values(self, *keys: _K) -> t.List[t.Any]: # type: ignore[override]\n if keys:\n d: t.List[t.Any] = []\n for key in keys:\n try:\n i = self.index(key)\n except KeyError:\n d.append(None)\n else:\n d.append(self[i])\n return d\n return list(self)","def items(self):\n return [(kvp.key, kvp.value) for kvp in self.keyvaluepair_set.all()]","def items(self):\n return zip(self._keys, self._values)","def list_values(key):\n return meta.list_values(key=key)","def items(self):\n return [(k, self[k]) for k in self.keys()]","def get_items(self, value, key=None):\n if key is None:\n return self.dicts(value)\n else:\n items = self.dicts(value)\n return [item[key] for item in items]","def values(self):\n return [ self[x] for x in self ]","def items(self):\n return [(key, self[key]) for key in self.keys()]","def items(self):\n return [(key, self[key]) for key in self.keys()]","def values(self):\n # Loop through all buckets\n # Collect all values in each bucket\n values_list = []\n\n for linked_list in self.buckets:\n for key_value_tuple in linked_list.items():\n values_list.append(key_value_tuple[1])\n\n return values_list","def values(self):\n # TODO: Collect all values in each of the buckets\n all_values = [] # Will store all the key\n\n for bucket in self.buckets:\n for value in bucket:\n if value is not None:\n all_values.append(value[1])\n return all_values","def items(self, *args, **kwargs):\n return [ (key, self._get(key, *args, **kwargs),) for key in self.keys(*args, **kwargs) ]","def obtain(self, key):\n if key in self:\n vals = self[key]\n else:\n vals = []\n dict.__setitem__(self, key, vals)\n return vals","def get_values(self) -> list:\r\n values = []\r\n for key, value in self._items:\r\n values.append(value)\r\n return values","def items(self):\n with self.__plock:\n return map(lambda key: (key, self[key]), self._keys)","def keys(self):\r\n return [key for key, value in self.iteritems()]","def get_for_key(self, key) -> list:\n return [res[key] for res in self.list]","def keys():","def values(self):\n return [_ for _ in self._dict.values()]","def items(self):\n x = []\n for k in list(self.keys()):\n x.append((k, self[k]))\n return x","def _get_keys(self, listOfKeys):\n return self._keys","def values(self, key=None, lo=None, hi=None, reverse=None, max=None,\n include=False, txn=None, rec=None):\n return itertools.imap(ITEMGETTER_1,\n self.items(key, lo, hi, reverse, max, include, txn, rec))","def keys(self):\n return [key for key, value in self.items()]","def values():","def values(self, values=None):\n return [self[key] for key in self._sequence]","async def _multi_get(self, keys):\n values = []\n for value in await self.client.multi_get(*keys):\n if value is not None and self.encoding is not None:\n values.append(bytes.decode(value))\n else:\n values.append(value)\n return values","def read_keyValues():\n # Create the list of CIs from our data\n ci = db.session.query(CI).order_by(CI.id).all()\n app.logger.debug(pformat(ci))\n # Serialize the data for the response\n ci_schema = CISchema(many=True)\n data = ci_schema.dump(ci)\n keyValues = []\n for d in data:\n keyValuePair = {}\n keyValuePair[\"key\"] = d.get(\"id\")\n keyValuePair[\"value\"] = d.get(\"value\")\n keyValues.append(keyValuePair)\n print(keyValues)\n return keyValues","def get_keys(self) -> Dict[str, str]:\n return self.http.get(self.config.paths.keys)","def keys(self):\r\n return [k for k in self]","def get_keys(self):\r\n return self._keys","async def keys(self) -> Iterable[str]:","def get_dictionary_items(self,dictionary):\r\n ret = []\r\n for key in self.get_dictionary_keys(dictionary):\r\n ret.extend((key,dictionary[key]))\r\n return ret","def items(self):\r\n return [(k, self[k]) for k in self]","def keys(self):\n return [kvp.key for kvp in self.keyvaluepair_set.all()]","def items(self):\r\n L = []\r\n for key, value in self.data.items():\r\n o = key()\r\n if o is not None:\r\n L.append((o, value))\r\n return L","def items(self):\r\n L = []\r\n for key, value in self.data.items():\r\n o = key()\r\n if o is not None:\r\n L.append((o, value))\r\n return L","def getAllValues(self, keyName):\n self._db._c.execute(\"SELECT \" + keyName + \" FROM \" + self.tableName)\n\n return [ col[0] for col in self._db._c.fetchall() ]","def itervalues(self, key=None):\n if key != None:\n vals = self.get(key)\n if vals != None:\n for val in vals:\n yield val\n else:\n for key in self.iterkeys():\n vals = self.get(key)\n for val in vals:\n yield val","def values(self):\n for key in self.metadb.values():\n yield key, self.datadb[key]","def getlist(self, key):\n try:\n return dict.__getitem__(self, key)\n except KeyError:\n return []","def get_norm_key_values(self, board):\n return self.key_values","async def values(self) -> Iterable[ResponseOrKey]:","def getkeys(self):\n return list(self.keys)","def valuerefs(self):\r\n return self.data.values()","def itervalues(self, *args, **kwargs):\n for key in self.iterkeys():\n yield self._get(key, *args, **kwargs)","def multiget(self, keys):\n result = {}\n for key in keys:\n result[key] = self.get(key)\n return result","def key_dict_values (self):\r\n\r\n if self.using_database:\r\n value_tuple = (notebookname,)\r\n db_cursor.execute(\"SELECT note_index \"\r\n +\"FROM keys_to_indexes\"\r\n +\" WHERE notebook=?;\",\r\n value_tuple)\r\n\r\n fetched = db_cursor.fetchall()\r\n if fetched:\r\n return {index[0].strip() for index in fetched}\r\n return set()\r\n\r\n return self.key_dict.values()","async def get_keys(self):\n return self.dict.keys()","def get_values(self, ckey):\n for next_key, item in yield_obj(self, ckey):\n if isdictinstance(item):\n for final, elem in yield_obj(item, next_key):\n if isdictinstance(elem) and elem.has_key(final):\n yield elem[final]\n else:\n yield elem\n elif isinstance(item, list) or isinstance(item, GeneratorType):\n for final, elem in item:\n for last, att in yield_obj(elem, final):\n if isdictinstance(att) and att.has_key(last):\n yield att[last]\n else:\n yield att","def getValues(self):\n return self.__get('values')","def collect(self, *keys):\n items = []\n for key in keys:\n if key.endswith(b\"*\"):\n key, explode = key[:-1], True\n else:\n explode = False\n if b\":\" in key:\n key, max_length = key.partition(b\":\")[0::2]\n max_length = int(max_length)\n else:\n max_length = None\n value = self.values.get(key)\n if isinstance(value, dict):\n if not value:\n items.append((key, None))\n elif explode:\n items.extend((key, _) for _ in value.items())\n else:\n items.append((key, value))\n elif isinstance(value, (tuple, list)):\n if explode:\n items.extend((key, _) for _ in value)\n else:\n items.append((key, list(value)))\n elif max_length is not None:\n items.append((key, value[:max_length]))\n else:\n items.append((key, value))\n return [(key, value) for key, value in items if value is not None]","def itervalues(self):\n for key in self:\n yield self[key]","def getlist(self, key):\n try:\n vals = _dict_getitem(self, key.lower())\n except KeyError:\n return []\n else:\n if isinstance(vals, tuple):\n return [vals[1]]\n else:\n return vals[1:]","def values(self) -> Dict[str, Any]:\n pass","def itervalues(self):\n return iter(kvp.value for kvp in self.keyvaluepair_set.all())","def getByPath(self, keys):\n return reduce(operator.getitem, keys, self._data)","def mget(self, keys: List[K]) -> List[Optional[V]]:\n raise NotImplementedError('mget must be reimplemented in concrete implementation')","def keys(self):\n return _keys(self)","def keys(self):\n return _keys(self)","def values(cls):\n if cls._values is None:\n cls._values = tuple(getattr(cls, attr) for attr in cls.keys())\n return cls._values","def items(self):\n acc = []\n for k in self.keys():\n pm = self._maps[k]\n acc.append((k,pm))\n return acc","def keys(self) -> ir.ArrayValue:\n return ops.MapKeys(self).to_expr()","def keysAll():","def keys(self, key=None, lo=None, hi=None, reverse=None, max=None,\n include=False, txn=None, rec=None):\n return itertools.imap(ITEMGETTER_0,\n self.items(key, lo, hi, reverse, max, include, txn, rec))","def Keys(self) -> _n_1_t_4:","def dict_values(d):\n return list(d.values())","async def values(cls):\n result = []\n for key in await ProxyMethod.channel.call_remote(\n \"%s.values\" % (cls.__namespace__,),\n ):\n result.append(cls(key=key))\n return result","def values(self):\n return self[\"values\"]","def values(self):\n return self[\"values\"]","def items(self, *keys):\n if keys:\n d = []\n for key in keys:\n try:\n i = self.index(key)\n except KeyError:\n d.append((key, None))\n else:\n d.append((self.__keys[i], self[i]))\n return d\n return list((self.__keys[i], self._super_getitem_single(i))\n for i in range(len(self)))","def keys(self):\n return list(self.token2id.values())","def keys(self, installer_context):\n return self.spec.keys(self.data, installer_context)","def items(self) -> tuple[tuple[Any, Any], ...]: # type: ignore\n return tuple(zip(self.keys(), self.values()))","def get_multi_values(site_name, keys, _current_parser=None):\n return {site_name: {key: get_value(site_name, key, _current_parser) for key in keys}}","def keys(self):\n return self.keys"],"string":"[\n \"def get_key_values(self):\\n return self.key_values\",\n \"def values(self):\\n with self.__plock:\\n return map(self.get, self._keys)\",\n \"def values(self):\\n return [self[k] for k in self.keys()]\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def values(self):\\n return [self[name] for name in self.keys()]\",\n \"def getall(self, key):\\n return self.values.get(key, [])\",\n \"def values(self, *args, **kwargs):\\n return [ self._get(doc, *args, **kwargs) for doc in self.keys(*args, **kwargs) ]\",\n \"def keyValues(self): # real signature unknown; restored from __doc__\\n return []\",\n \"def getitems(self):\\n return {k:self.get(k) for k in self.keys}\",\n \"def values(self):\\n x = []\\n for k in list(self.keys()):\\n x.append(self[k])\\n return x\",\n \"def values(self):\\r\\n return [self[k] for k in self]\",\n \"def values(self):\\n values = []\\n for key in self.keys():\\n values.append(self[key])\\n return values\",\n \"def valsForKeys(h, *keys):\\n return [h[k] for k in keys]\",\n \"def items(self):\\n return ((key, value) for (key, value) in zip(self.__keys, self.__vals))\",\n \"def values(self):\\n return self.d.keys()\",\n \"def values(self):\\n return [kvp.value for kvp in self.keyvaluepair_set.all()]\",\n \"def get_many(self, *keys):\\n key_x_value = self.get_dict(*keys)\\n return [key_x_value[key] for key in keys]\",\n \"def values(\\n self, *keys: _TResultKey\\n ) -> t.List[t.List[t.Any]]:\\n return [record.values(*keys) for record in self]\",\n \"def get_cursor_values(self, keys: Set[str]) -> Mapping[str, str]:\",\n \"def _key_vals(dict_):\\n return [(key, val) for key, val in dict_.iteritems()]\",\n \"def items(self):\\n return list(zip(self.keys(), self.values()))\",\n \"def items(self):\\n return list(zip(self.keys(), self.values()))\",\n \"def get_dictionary_values(self,dictionary):\\r\\n return [dictionary[k] for k in self.get_dictionary_keys(dictionary)]\",\n \"def multiget(self, keys):\\n return self.sp.multiget(keys)\",\n \"def values(self, *keys: _K) -> t.List[t.Any]: # type: ignore[override]\\n if keys:\\n d: t.List[t.Any] = []\\n for key in keys:\\n try:\\n i = self.index(key)\\n except KeyError:\\n d.append(None)\\n else:\\n d.append(self[i])\\n return d\\n return list(self)\",\n \"def items(self):\\n return [(kvp.key, kvp.value) for kvp in self.keyvaluepair_set.all()]\",\n \"def items(self):\\n return zip(self._keys, self._values)\",\n \"def list_values(key):\\n return meta.list_values(key=key)\",\n \"def items(self):\\n return [(k, self[k]) for k in self.keys()]\",\n \"def get_items(self, value, key=None):\\n if key is None:\\n return self.dicts(value)\\n else:\\n items = self.dicts(value)\\n return [item[key] for item in items]\",\n \"def values(self):\\n return [ self[x] for x in self ]\",\n \"def items(self):\\n return [(key, self[key]) for key in self.keys()]\",\n \"def items(self):\\n return [(key, self[key]) for key in self.keys()]\",\n \"def values(self):\\n # Loop through all buckets\\n # Collect all values in each bucket\\n values_list = []\\n\\n for linked_list in self.buckets:\\n for key_value_tuple in linked_list.items():\\n values_list.append(key_value_tuple[1])\\n\\n return values_list\",\n \"def values(self):\\n # TODO: Collect all values in each of the buckets\\n all_values = [] # Will store all the key\\n\\n for bucket in self.buckets:\\n for value in bucket:\\n if value is not None:\\n all_values.append(value[1])\\n return all_values\",\n \"def items(self, *args, **kwargs):\\n return [ (key, self._get(key, *args, **kwargs),) for key in self.keys(*args, **kwargs) ]\",\n \"def obtain(self, key):\\n if key in self:\\n vals = self[key]\\n else:\\n vals = []\\n dict.__setitem__(self, key, vals)\\n return vals\",\n \"def get_values(self) -> list:\\r\\n values = []\\r\\n for key, value in self._items:\\r\\n values.append(value)\\r\\n return values\",\n \"def items(self):\\n with self.__plock:\\n return map(lambda key: (key, self[key]), self._keys)\",\n \"def keys(self):\\r\\n return [key for key, value in self.iteritems()]\",\n \"def get_for_key(self, key) -> list:\\n return [res[key] for res in self.list]\",\n \"def keys():\",\n \"def values(self):\\n return [_ for _ in self._dict.values()]\",\n \"def items(self):\\n x = []\\n for k in list(self.keys()):\\n x.append((k, self[k]))\\n return x\",\n \"def _get_keys(self, listOfKeys):\\n return self._keys\",\n \"def values(self, key=None, lo=None, hi=None, reverse=None, max=None,\\n include=False, txn=None, rec=None):\\n return itertools.imap(ITEMGETTER_1,\\n self.items(key, lo, hi, reverse, max, include, txn, rec))\",\n \"def keys(self):\\n return [key for key, value in self.items()]\",\n \"def values():\",\n \"def values(self, values=None):\\n return [self[key] for key in self._sequence]\",\n \"async def _multi_get(self, keys):\\n values = []\\n for value in await self.client.multi_get(*keys):\\n if value is not None and self.encoding is not None:\\n values.append(bytes.decode(value))\\n else:\\n values.append(value)\\n return values\",\n \"def read_keyValues():\\n # Create the list of CIs from our data\\n ci = db.session.query(CI).order_by(CI.id).all()\\n app.logger.debug(pformat(ci))\\n # Serialize the data for the response\\n ci_schema = CISchema(many=True)\\n data = ci_schema.dump(ci)\\n keyValues = []\\n for d in data:\\n keyValuePair = {}\\n keyValuePair[\\\"key\\\"] = d.get(\\\"id\\\")\\n keyValuePair[\\\"value\\\"] = d.get(\\\"value\\\")\\n keyValues.append(keyValuePair)\\n print(keyValues)\\n return keyValues\",\n \"def get_keys(self) -> Dict[str, str]:\\n return self.http.get(self.config.paths.keys)\",\n \"def keys(self):\\r\\n return [k for k in self]\",\n \"def get_keys(self):\\r\\n return self._keys\",\n \"async def keys(self) -> Iterable[str]:\",\n \"def get_dictionary_items(self,dictionary):\\r\\n ret = []\\r\\n for key in self.get_dictionary_keys(dictionary):\\r\\n ret.extend((key,dictionary[key]))\\r\\n return ret\",\n \"def items(self):\\r\\n return [(k, self[k]) for k in self]\",\n \"def keys(self):\\n return [kvp.key for kvp in self.keyvaluepair_set.all()]\",\n \"def items(self):\\r\\n L = []\\r\\n for key, value in self.data.items():\\r\\n o = key()\\r\\n if o is not None:\\r\\n L.append((o, value))\\r\\n return L\",\n \"def items(self):\\r\\n L = []\\r\\n for key, value in self.data.items():\\r\\n o = key()\\r\\n if o is not None:\\r\\n L.append((o, value))\\r\\n return L\",\n \"def getAllValues(self, keyName):\\n self._db._c.execute(\\\"SELECT \\\" + keyName + \\\" FROM \\\" + self.tableName)\\n\\n return [ col[0] for col in self._db._c.fetchall() ]\",\n \"def itervalues(self, key=None):\\n if key != None:\\n vals = self.get(key)\\n if vals != None:\\n for val in vals:\\n yield val\\n else:\\n for key in self.iterkeys():\\n vals = self.get(key)\\n for val in vals:\\n yield val\",\n \"def values(self):\\n for key in self.metadb.values():\\n yield key, self.datadb[key]\",\n \"def getlist(self, key):\\n try:\\n return dict.__getitem__(self, key)\\n except KeyError:\\n return []\",\n \"def get_norm_key_values(self, board):\\n return self.key_values\",\n \"async def values(self) -> Iterable[ResponseOrKey]:\",\n \"def getkeys(self):\\n return list(self.keys)\",\n \"def valuerefs(self):\\r\\n return self.data.values()\",\n \"def itervalues(self, *args, **kwargs):\\n for key in self.iterkeys():\\n yield self._get(key, *args, **kwargs)\",\n \"def multiget(self, keys):\\n result = {}\\n for key in keys:\\n result[key] = self.get(key)\\n return result\",\n \"def key_dict_values (self):\\r\\n\\r\\n if self.using_database:\\r\\n value_tuple = (notebookname,)\\r\\n db_cursor.execute(\\\"SELECT note_index \\\"\\r\\n +\\\"FROM keys_to_indexes\\\"\\r\\n +\\\" WHERE notebook=?;\\\",\\r\\n value_tuple)\\r\\n\\r\\n fetched = db_cursor.fetchall()\\r\\n if fetched:\\r\\n return {index[0].strip() for index in fetched}\\r\\n return set()\\r\\n\\r\\n return self.key_dict.values()\",\n \"async def get_keys(self):\\n return self.dict.keys()\",\n \"def get_values(self, ckey):\\n for next_key, item in yield_obj(self, ckey):\\n if isdictinstance(item):\\n for final, elem in yield_obj(item, next_key):\\n if isdictinstance(elem) and elem.has_key(final):\\n yield elem[final]\\n else:\\n yield elem\\n elif isinstance(item, list) or isinstance(item, GeneratorType):\\n for final, elem in item:\\n for last, att in yield_obj(elem, final):\\n if isdictinstance(att) and att.has_key(last):\\n yield att[last]\\n else:\\n yield att\",\n \"def getValues(self):\\n return self.__get('values')\",\n \"def collect(self, *keys):\\n items = []\\n for key in keys:\\n if key.endswith(b\\\"*\\\"):\\n key, explode = key[:-1], True\\n else:\\n explode = False\\n if b\\\":\\\" in key:\\n key, max_length = key.partition(b\\\":\\\")[0::2]\\n max_length = int(max_length)\\n else:\\n max_length = None\\n value = self.values.get(key)\\n if isinstance(value, dict):\\n if not value:\\n items.append((key, None))\\n elif explode:\\n items.extend((key, _) for _ in value.items())\\n else:\\n items.append((key, value))\\n elif isinstance(value, (tuple, list)):\\n if explode:\\n items.extend((key, _) for _ in value)\\n else:\\n items.append((key, list(value)))\\n elif max_length is not None:\\n items.append((key, value[:max_length]))\\n else:\\n items.append((key, value))\\n return [(key, value) for key, value in items if value is not None]\",\n \"def itervalues(self):\\n for key in self:\\n yield self[key]\",\n \"def getlist(self, key):\\n try:\\n vals = _dict_getitem(self, key.lower())\\n except KeyError:\\n return []\\n else:\\n if isinstance(vals, tuple):\\n return [vals[1]]\\n else:\\n return vals[1:]\",\n \"def values(self) -> Dict[str, Any]:\\n pass\",\n \"def itervalues(self):\\n return iter(kvp.value for kvp in self.keyvaluepair_set.all())\",\n \"def getByPath(self, keys):\\n return reduce(operator.getitem, keys, self._data)\",\n \"def mget(self, keys: List[K]) -> List[Optional[V]]:\\n raise NotImplementedError('mget must be reimplemented in concrete implementation')\",\n \"def keys(self):\\n return _keys(self)\",\n \"def keys(self):\\n return _keys(self)\",\n \"def values(cls):\\n if cls._values is None:\\n cls._values = tuple(getattr(cls, attr) for attr in cls.keys())\\n return cls._values\",\n \"def items(self):\\n acc = []\\n for k in self.keys():\\n pm = self._maps[k]\\n acc.append((k,pm))\\n return acc\",\n \"def keys(self) -> ir.ArrayValue:\\n return ops.MapKeys(self).to_expr()\",\n \"def keysAll():\",\n \"def keys(self, key=None, lo=None, hi=None, reverse=None, max=None,\\n include=False, txn=None, rec=None):\\n return itertools.imap(ITEMGETTER_0,\\n self.items(key, lo, hi, reverse, max, include, txn, rec))\",\n \"def Keys(self) -> _n_1_t_4:\",\n \"def dict_values(d):\\n return list(d.values())\",\n \"async def values(cls):\\n result = []\\n for key in await ProxyMethod.channel.call_remote(\\n \\\"%s.values\\\" % (cls.__namespace__,),\\n ):\\n result.append(cls(key=key))\\n return result\",\n \"def values(self):\\n return self[\\\"values\\\"]\",\n \"def values(self):\\n return self[\\\"values\\\"]\",\n \"def items(self, *keys):\\n if keys:\\n d = []\\n for key in keys:\\n try:\\n i = self.index(key)\\n except KeyError:\\n d.append((key, None))\\n else:\\n d.append((self.__keys[i], self[i]))\\n return d\\n return list((self.__keys[i], self._super_getitem_single(i))\\n for i in range(len(self)))\",\n \"def keys(self):\\n return list(self.token2id.values())\",\n \"def keys(self, installer_context):\\n return self.spec.keys(self.data, installer_context)\",\n \"def items(self) -> tuple[tuple[Any, Any], ...]: # type: ignore\\n return tuple(zip(self.keys(), self.values()))\",\n \"def get_multi_values(site_name, keys, _current_parser=None):\\n return {site_name: {key: get_value(site_name, key, _current_parser) for key in keys}}\",\n \"def keys(self):\\n return self.keys\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78560966","0.7809564","0.7629101","0.76030433","0.76030433","0.76030433","0.75565445","0.7534844","0.75304735","0.7513847","0.74225706","0.73467046","0.72960025","0.7254402","0.7246637","0.71887136","0.70794696","0.7065934","0.6987683","0.69494283","0.6942988","0.6925193","0.6921116","0.6921116","0.68971395","0.6884749","0.68643177","0.6851204","0.6831352","0.6824089","0.68004936","0.6776986","0.67650104","0.6751484","0.6751484","0.67084974","0.67026925","0.67013144","0.66988117","0.66950595","0.6649915","0.663744","0.66226304","0.661625","0.65910095","0.65902376","0.6590174","0.65851146","0.6567864","0.65675735","0.6543684","0.65124464","0.6472351","0.64627516","0.64473814","0.6436263","0.64196295","0.6419472","0.6410377","0.64061207","0.64008796","0.64008796","0.6389831","0.6389107","0.6376249","0.63646686","0.635905","0.63577265","0.6351017","0.63487625","0.6347494","0.6338","0.6337458","0.6324117","0.63229364","0.6322733","0.631857","0.6317678","0.6294077","0.62873614","0.62689227","0.6264965","0.62629557","0.62448233","0.62448233","0.62408775","0.6236584","0.6236434","0.6235009","0.6234189","0.62341493","0.6213993","0.621047","0.6204516","0.6204516","0.6189985","0.6187333","0.61866724","0.6186162","0.61846876","0.61814475"],"string":"[\n \"0.78560966\",\n \"0.7809564\",\n \"0.7629101\",\n \"0.76030433\",\n \"0.76030433\",\n \"0.76030433\",\n \"0.75565445\",\n \"0.7534844\",\n \"0.75304735\",\n \"0.7513847\",\n \"0.74225706\",\n \"0.73467046\",\n \"0.72960025\",\n \"0.7254402\",\n \"0.7246637\",\n \"0.71887136\",\n \"0.70794696\",\n \"0.7065934\",\n \"0.6987683\",\n \"0.69494283\",\n \"0.6942988\",\n \"0.6925193\",\n \"0.6921116\",\n \"0.6921116\",\n \"0.68971395\",\n \"0.6884749\",\n \"0.68643177\",\n \"0.6851204\",\n \"0.6831352\",\n \"0.6824089\",\n \"0.68004936\",\n \"0.6776986\",\n \"0.67650104\",\n \"0.6751484\",\n \"0.6751484\",\n \"0.67084974\",\n \"0.67026925\",\n \"0.67013144\",\n \"0.66988117\",\n \"0.66950595\",\n \"0.6649915\",\n \"0.663744\",\n \"0.66226304\",\n \"0.661625\",\n \"0.65910095\",\n \"0.65902376\",\n \"0.6590174\",\n \"0.65851146\",\n \"0.6567864\",\n \"0.65675735\",\n \"0.6543684\",\n \"0.65124464\",\n \"0.6472351\",\n \"0.64627516\",\n \"0.64473814\",\n \"0.6436263\",\n \"0.64196295\",\n \"0.6419472\",\n \"0.6410377\",\n \"0.64061207\",\n \"0.64008796\",\n \"0.64008796\",\n \"0.6389831\",\n \"0.6389107\",\n \"0.6376249\",\n \"0.63646686\",\n \"0.635905\",\n \"0.63577265\",\n \"0.6351017\",\n \"0.63487625\",\n \"0.6347494\",\n \"0.6338\",\n \"0.6337458\",\n \"0.6324117\",\n \"0.63229364\",\n \"0.6322733\",\n \"0.631857\",\n \"0.6317678\",\n \"0.6294077\",\n \"0.62873614\",\n \"0.62689227\",\n \"0.6264965\",\n \"0.62629557\",\n \"0.62448233\",\n \"0.62448233\",\n \"0.62408775\",\n \"0.6236584\",\n \"0.6236434\",\n \"0.6235009\",\n \"0.6234189\",\n \"0.62341493\",\n \"0.6213993\",\n \"0.621047\",\n \"0.6204516\",\n \"0.6204516\",\n \"0.6189985\",\n \"0.6187333\",\n \"0.61866724\",\n \"0.6186162\",\n \"0.61846876\",\n \"0.61814475\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14879,"cells":{"query":{"kind":"string","value":"Remove list of keys from the store"},"document":{"kind":"string","value":"def delete(self, keys: List[K]) -> List[bool]:\n raise NotImplementedError('delete must be reimplemented in concrete implementation')"},"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 removeAllKeys(self) -> None:\n ...","def delete_many(self, keys):\n raise NotImplementedError()","def rem(self, keys: Union[str, Iterable]):\n return(self.db.delVal(db=self.sdb, key=self._tokey(keys)))","def rem(self, keys: Union[str, Iterable]):\n return(self.db.delVal(db=self.sdb, key=self._tokey(keys)))","def rem(self, keys: Union[str, Iterable]):\n return(self.db.delVal(db=self.sdb, key=self._tokey(keys)))","def remove_states(self, keys: list):\n if self.spec.graph:\n self.spec.graph.clear_children(keys)","def clear_flush_lists(self, keys):\r\n cache.delete_many(keys)","def remove(self, key):","def remove_item_from_all_keys(self, item):\n for key in self._reverse_store[item]:\n self[key].remove(item)\n del self._reverse_store[item]","def delete_many(self, keys):\n return self.delete_many_values(keys)","def remove_by_keys(self, keys):\n return list(filter(lambda item: item.keyword not in set(keys), self._metadata))","def remove_keys(data: dict, keys: list[str]) -> None:\n for k in keys:\n _ = data.pop(k, None)","def delete_lists():\n del SAVE_EXISTENT[:]\n del SAVE_PRICE[:]\n del CARDS[:]","def del_all(self, items):\n for item in items:\n item.key.delete()\n logger.debug(\"Deleted all the items\")","def delete(self, key):","def eliminate_key (self,key):\r\n\r\n if self.using_shelf:\r\n\r\n del self.key_dict[str(key)]","def delete_many(self, keys):\n try:\n if keys:\n self._cache.delete(*map(self.prepare_key, keys))\n except Exception as err:\n return self.warn_or_error(err)","def delete_key_HELPER(data_dict, key_list, key_to_delete):\n data_dict = get_key_from_dict_HELPER(data_dict, key_list[:-1])\n data_dict.pop(key_to_delete)\n return data_dict","def delete(\n self, keys: Optional[Iterable[Text]] = None\n ) -> Dict[Text, StateDictInterface]:\n records = self.execute()\n assert isinstance(records, dict)\n\n self.store.delete_many(records.values(), keys=keys)\n return records","def _remove_swarm_keys(self):\n for key in SWARM_PROPERTIES:\n self.spec.pop(key, None)","def clearStore(self):\n os.remove(self.uid+\".pcl\")\n self.items = []","def delete_many(self, *keys):\n self.collection.remove({'_id': {'$in': keys}})\n return True","def remove(self, key):\n pass","def clear_all(self):\n for key in list(self.keys):\n os.remove(self._get_path(key))\n self.keys.remove(key)","def removeKeys(self, attributeIndex, view) -> None:\n ...","def _remove_certs_keys(self, cert_list): # pylint: disable=no-self-use\n # This must occur first, LIST is the official key\n self._remove_certs_from_list(cert_list)\n\n # Remove files\n for cert in cert_list:\n os.remove(cert.backup_path)\n os.remove(cert.backup_key_path)","def delete(cls, *keys):\n todelete = []\n namespace, kind, member = Schema.Get(cls)\n for key in keys:\n assert isinstance(key, str)\n todelete.append(Key(namespace, kind, key)) \n Lisa.delete(*todelete)","def __delitem__(self, key: tuple):\n s, a = key\n del self.store[s][a]","def keep_in_dictionary(self,dictionary,*keys):\r\n remove_keys = [k for k in dictionary if k not in keys]\r\n self.remove_from_dictionary(dictionary,*remove_keys)","def clearKeys(self):\n for attr in self._filter():\n pm.cutKey(attr)","def purge(self):\n keys = [k for (k, v) in self.get_range()]\n\n [self.remove(k) for k in keys]","def remove_keys(d, keys):\n pp = deepcopy(d)\n if isinstance(keys, (list, tuple)):\n for k in keys:\n pp.pop(k, None)\n else:\n pp.pop(keys, None)\n return pp","def remove(self, key: int) -> None:\n t = key % 20011\n delete = []\n for item in self.hash[t]:\n if item[0] == key:\n delete = item\n if delete:\n self.hash[t].remove(delete)","def __delitem__(self, key):\n\t\tdel self.__dStore[key]","def __delitem__(self, key):\n del self.list[key]","def __delitem__(self, key: Union[Hashable, Sequence[Hashable]]) -> None:\n self.contents = {i: self.contents[i] for i in self.contents \n if i not in more_itertools.always_iterable(key)}\n return","def remove(self, key):\n if key in self._store:\n del self._store[key]","def delete(cls, keys, pipe=None):\n with cls._pipe(pipe) as pipe:\n core = cls.core(pipe)\n core.delete(*keys)","def clear(self):\n for key in self.keys():\n del self[key]","def del_seqs(self, keys):\n for j in range(len(keys)):\n del self._d_seqs[keys[j]]\n self._num_seqs = int(len(self._d_seqs))\n self._d_seqs = self._d_seqs\n self._seqs = list(self._d_seqs)","def strip_key_strings(po):\r\n newlist = [entry for entry in po if not is_key_string(entry.msgid)]\r\n del po[:]\r\n po += newlist","def __delitem__(self, key):\n self.f_remove(key)","def prune_option_list(opts, keys):\n opt_d = opt_to_dict(opts)\n for k in keys:\n if k in opt_d:\n del opt_d[k]\n return [k for item in opt_d.iteritems() for k in item]","def invalidate_keys(self, keys):\r\n if not keys:\r\n return\r\n flush, flush_keys = self.find_flush_lists(keys)\r\n\r\n if flush:\r\n cache.delete_many(flush)\r\n if flush_keys:\r\n self.clear_flush_lists(flush_keys)","def clear():\n global d\n for key in d.keys():\n del d[key]","def prune(self): # HashMap.prune\n for hashval, list in self.contentHash.iteritems():\n newlist=[]\n for entry in list:\n if not entry.deleted:\n newlist.append(entry)\n self.contentHash[hashval]=newlist","def dal_delete(key):\n global store\n return store.delete(urllib.quote(key))","def delete(self, key):\n pass","def delete(self, key):\n pass","def remove(self):\n for db in self.values():\n db.remove()","def remove(self, key_name: str):\n pass","def test_remove_multiple_key(self):\n\n expected = {\n \"Hello\": \"world\",\n \"World\": {\"world\": \"hello\"},\n \"pyfunceble\": [\"funilrys\"],\n }\n\n actual = Dict(self.test_subject).remove_key([\"funilrys\", \"Py\"])\n\n self.assertEqual(expected, actual)","def without_keys(keys):\n keys = frozenset(keys) # frozenset has efficient membership lookup\n return filter_keys_c(fnot(partial(operator.contains, keys)))","def _remove_data(things, lst_remove=None):\n\n for data in things:\n data.pop(\"_sa_instance_state\", None)\n data.pop(\"user_id\", None)\n\n if lst_remove is not None:\n for str_remove in lst_remove:\n if str_remove in data:\n data.pop(str_remove, None)\n\n return things","def removeall(self):\n\n # If there used to be a key, there must exist an old value blob somewhere in the database. It should be deallocated after a successful commit to disk.\n for key in self.keys:\n if self.keys[key] is not None:\n punchat,punchlen = self.keys[key]\n self.awaitingpunch.append((punchat, punchlen))\n \n self.keys = {}\n self.buffered = {}\n self.cache = {}\n \n if self.autocommit:\n commit()","async def delete(self, *keys, **kwargs):\n\n def gen_keys(keys):\n all_keys = []\n for key in keys:\n if isinstance(key, list):\n all_keys += gen_keys(keys=key)\n else:\n all_keys.append(key)\n return all_keys\n\n all_keys = gen_keys(keys)\n for key in all_keys:\n await self._client_conn.hdel(key=self.name, field=key)","def remove_all():\n storage = FileStorage()\n objects = storage.all()\n objects = list(objects.values())\n\n for element in objects:\n storage.delete(element)\n objects = storage.all()","def multi_del(self, keys, no_update_log=False):\n # TODO: write better documentation: why would user need the no_update_log param?\n opts = (no_update_log and TyrantProtocol.RDBMONOULOG or 0)\n if not isinstance(keys, (list, tuple)):\n keys = list(keys)\n\n wait(self.proto.misc(\"outlist\", keys, opts))","def flushdb(self):\n allKeys = self.redis.keys(self.appendKeys(\"*\"))\n # for some reason deleteing with a list of keys isn't working\n p = self.redis.pipeline()\n for key in allKeys:\n p.delete(key)\n p.execute()","def remove(self, key):\n h = key%self.m\n a = self.a\n if a[h]:\n a[h] = None","def __delitem__(self, key):\n pass","def __delitem__(self, key):\n pass","def mRemove(self, **kw):\n kw = copy_non_reserved_keywords(kw)\n for key, val in kw.items():\n # It would be easier on the eyes to write this using\n # \"continue\" statements whenever we finish processing an item,\n # but Python 1.5.2 apparently doesn't let you use \"continue\"\n # within try:-except: blocks, so we have to nest our code.\n try:\n orig = self._dict[key]\n except KeyError:\n # No existing variable in the environment, so just skip it\n pass\n else:\n try:\n # Most straightforward: just try to substract it.\n # But this will not work in most cases :-(\n self._dict[key] = orig - val\n except TypeError:\n try:\n # It orig and val is dictionaties:\n for k in val.keys():\n del orig[k]\n # May be some recursion ?\n except AttributeError:\n try:\n # Check if the original is a list.\n remove_from_orig = orig.remove\n except AttributeError:\n # Can't do nothing more\n pass\n else:\n # The original is a list, so remove\n # value from it.\n try:\n i = val[0]\n except TypeError:\n val = [ val ]\n for i in val:\n try:\n remove_from_orig(i)\n except ValueError:\n pass\n self.scanner_map_delete(kw)","def remove_key(self, key):\n del self.data[key]\n self.save_data()","def remove(self, *names):\n for name in names:\n self._storage.pop(name, None)","def discard_index_from_key(self,key,index):\r\n\r\n # with shelf\r\n if self.using_shelf:\r\n\r\n if key in self.key_dict:\r\n\r\n self.key_dict[key].discard(str(index))\r\n\r\n\r\n #with database\r\n if self.using_database:\r\n value_tuple = (notebookname,key,str(index),)\r\n db_cursor.execute(\"DELETE FROM\"\r\n +\" keys_to_indexes\"\r\n +\" WHERE notebook=?\"\r\n +\" AND keyword=?\"\r\n +\" AND note_index=?;\",\r\n value_tuple)\r\n\r\n db_cursor.execute(\"SELECT * FROM\"\r\n +\" keys_to_indexes\"\r\n +\" WHERE notebook=?\"\r\n +\" and keyword=?;\",\r\n value_tuple[0:2])\r\n if db_cursor.fetchone():\r\n db_cursor.execute(\"DELETE FROM\"\r\n +\" all_keys WHERE notebook=?\"\r\n +\" AND keyword=?;\",\r\n value_tuple[0:2])","def removeAll(self):\n self.pDict.clear()","def remove_index_from_key(self,key,index):\r\n\r\n #with shelf\r\n if self.using_shelf:\r\n\r\n self.key_dict[key].remove(str(index))\r\n\r\n #with database\r\n if self.using_database:\r\n value_tuple = (notebookname,key,str(index))\r\n db_cursor.execute(\"DELETE FROM \"\r\n +\"keys_to_indexes \"\r\n +\"WHERE notebook=? \"\r\n +\"AND keyword=? \"\r\n +\"AND note_index=?;\",\r\n value_tuple)\r\n\r\n db_cursor.execute(\"SELECT * FROM \"\r\n +\"keys_to_indexes \"\r\n +\"WHERE notebook=? and keyword=?;\",\r\n value_tuple[0:2])\r\n if db_cursor.fetchone():\r\n db_cursor.execute(\"DELETE FROM \"\r\n +\"all_keys WHERE notebook=? \"\r\n +\"AND keyword=?;\",\r\n value_tuple[0:2])","def delete_many(self, keys, version=None, client=None):\r\n\r\n if client is None:\r\n client = self.get_client(write=True)\r\n\r\n if not keys:\r\n return\r\n\r\n keys = [self.make_key(k, version=version) for k in keys]\r\n try:\r\n return client.delete(*keys)\r\n except ConnectionError:\r\n raise ConnectionInterrupted(connection=client)","def __delitem__(self, key):\n del self._get_storage()[key]","def clear(self):\n self.keyvaluepair_set.all().delete()","def __delitem__(self, key):\n self.delete(key)","def __delitem__(self, key):\n self.delete(key)","def remove(self, key: int | str):\n self.__delitem__(key)","def remove(self, key):\n try:\n del self._store[key]\n except KeyError:\n pass","def __delitem__(self, key):\n self.deleteAttributes([key])","def remove():","def __delitem__(self, key: tuple):\n s, a = key\n if not isinstance(s, self.observation_space) or not isinstance(a, self.action_space):\n raise KeyError\n del self.store[s][a]","def remove_key(self, key, save_pkl=True):\r\n self.keys.remove(key)\r\n if save_pkl:\r\n self.save_pkl()","def remove_keys(_dict, _keys):\n if isinstance(_keys, str):\n if _keys in _dict:\n del _dict[_keys]\n else:\n for _key in _keys:\n _dict = remove_keys(_dict, _key)\n return _dict","def remove_from_kvstore(helper, name, rm_entries, stats):\n if not rm_entries:\n return\n\n helper.log_info('Removing {0} kvstore entries for MineMeld feed \"{1}\"'.format(\n len(rm_entries), name))\n url = _uri(helper)\n headers = _headers(helper)\n\n # Batch a few at a time, as splunk 414s if the URI is too long, or times\n # out if it's within the length limits but still hits too many entries to\n # finish on time. From some tests, it seems like 500 is a good number,\n # which is nice since it matches the batch_save number.\n #\n # The _key field has been 24 characters in length on my system.\n for i in range(0, len(rm_entries), 500):\n rms = rm_entries[i:i+500]\n query = {'$or': list({'_key': x} for x in rms)}\n resp = helper.send_http_request(\n url=url,\n headers=headers,\n method='DELETE',\n verify=False,\n parameters={'query': json.dumps(query)})\n resp.raise_for_status()","def clear(self, lifetime):\n\n # find all entries with the specified lifetime\n to_remove = [k for (k, v) in self.store.items() if v[0] == lifetime]\n # remove all these entries from the list\n for t in to_remove:\n del self.store[t]","def remove_data(self, data_keys):\r\n self._verify_key_types(name='data', keys=data_keys)\r\n if isinstance(data_keys, (str, unicode)):\r\n data_keys = [data_keys]\r\n for data_key in data_keys:\r\n del self[data_key]","def delete(self,key):\n\n pass","def leftdelalllistitems(self):\n self._leftlist.delete()","def __delitem__(self,key):\n if key in self._register:\n del self._register[key]","def _clean_first_key_from_registry(self):\n # only clean the first entry from the list\n to_clean = self._buffered_backend_keys[0]\n for registry_key in list(self.chunks_registry.keys()):\n if to_clean in registry_key:\n del self.chunks_registry[registry_key]\n del self._buffered_backend_keys[0]","def rightdelalllistitems(self):\n self._rightlist.delete()","def test_remove():\n # remove dict keys\n schema = Schema({\"weight\": int,\n Remove(\"color\"): str,\n Remove(\"amount\"): int})\n out_ = schema({\"weight\": 10, \"color\": \"red\", \"amount\": 1})\n assert \"color\" not in out_ and \"amount\" not in out_\n\n # remove keys by type\n schema = Schema({\"weight\": float,\n \"amount\": int,\n # remvove str keys with int values\n Remove(str): int,\n # keep str keys with str values\n str: str})\n out_ = schema({\"weight\": 73.4,\n \"condition\": \"new\",\n \"amount\": 5,\n \"left\": 2})\n # amount should stay since it's defined\n # other string keys with int values will be removed\n assert \"amount\" in out_ and \"left\" not in out_\n # string keys with string values will stay\n assert \"condition\" in out_\n\n # remove value from list\n schema = Schema([Remove(1), int])\n out_ = schema([1, 2, 3, 4, 1, 5, 6, 1, 1, 1])\n assert_equal(out_, [2, 3, 4, 5, 6])\n\n # remove values from list by type\n schema = Schema([1.0, Remove(float), int])\n out_ = schema([1, 2, 1.0, 2.0, 3.0, 4])\n assert_equal(out_, [1, 2, 1.0, 4])","def delete_obsolete_command_items(default, control):\n delete_keys = []\n for cmd_id in control:\n if cmd_id not in default:\n delete_keys.append(cmd_id)\n\n for key in delete_keys:\n del control[key]","def _delKey(self, key):\n pass","def remove(self, key):\r\n for i in range(len(self.lis)):\r\n if self.lis[i][0] == key:\r\n self.lis.pop(i)\r\n break","def __delitem__(self, key):\n del self.elements[key]","def delete_keys_tags(self,\r\n index,\r\n deletedkeys):\r\n\r\n\r\n for k_temp in deletedkeys:\r\n k_temp = k_temp.strip()\r\n if k_temp in set(self.get_keys()):\r\n self.discard_index_from_key(k_temp, index)\r\n if self.get_indexes_for_key(k_temp) == set():\r\n self.eliminate_key(k_temp)\r\n for t_temp in self.get_tags():\r\n if k_temp in self.get_keys_for_tag(t_temp):\r\n self.discard_key_from_tag(t_temp,k_temp)\r\n if not self.get_keys_for_tag(t_temp):\r\n self.delete_tag(t_temp)","def _remove_keys(results: dict, remove: list) -> dict:\n removed = {}\n for key, val in results.items():\n if key not in remove:\n removed[key] = val\n return removed","def delete(self, *names):\n\n return [shard.delete(*keys) for shard, keys\n in self.gather_keys_by_shard(names)]","def middledelalllistitems(self):\n self._linklist.delete()","def discard_key_from_tag(self,tag,key):\r\n\r\n # with shelf\r\n if self.using_shelf:\r\n\r\n self.tag_dict[tag].discard(key)\r\n\r\n\r\n #with database\r\n if self.using_database:\r\n value_tuple = (notebookname,tag,key,)\r\n db_cursor.execute(\"DELETE FROM tags_to_keys\"\r\n +\" WHERE notebook=? AND tag=?\"\r\n +\" AND keyword=?;\",\r\n value_tuple)","def f_remove(self, *args):\n for arg in args:\n arg = self.f_translate_key(arg)\n if arg in self._data:\n del self._data[arg]\n else:\n raise AttributeError(\n \"Your result `%s` does not contain %s.\" % (self.name_, arg)\n )","def remove(self, key):\n match = self.find(key)\n if not match:\n raise UserDBValueError(\"Element not found in list\")\n\n self._elements = [this for this in self._elements if this != match]\n return self"],"string":"[\n \"def removeAllKeys(self) -> None:\\n ...\",\n \"def delete_many(self, keys):\\n raise NotImplementedError()\",\n \"def rem(self, keys: Union[str, Iterable]):\\n return(self.db.delVal(db=self.sdb, key=self._tokey(keys)))\",\n \"def rem(self, keys: Union[str, Iterable]):\\n return(self.db.delVal(db=self.sdb, key=self._tokey(keys)))\",\n \"def rem(self, keys: Union[str, Iterable]):\\n return(self.db.delVal(db=self.sdb, key=self._tokey(keys)))\",\n \"def remove_states(self, keys: list):\\n if self.spec.graph:\\n self.spec.graph.clear_children(keys)\",\n \"def clear_flush_lists(self, keys):\\r\\n cache.delete_many(keys)\",\n \"def remove(self, key):\",\n \"def remove_item_from_all_keys(self, item):\\n for key in self._reverse_store[item]:\\n self[key].remove(item)\\n del self._reverse_store[item]\",\n \"def delete_many(self, keys):\\n return self.delete_many_values(keys)\",\n \"def remove_by_keys(self, keys):\\n return list(filter(lambda item: item.keyword not in set(keys), self._metadata))\",\n \"def remove_keys(data: dict, keys: list[str]) -> None:\\n for k in keys:\\n _ = data.pop(k, None)\",\n \"def delete_lists():\\n del SAVE_EXISTENT[:]\\n del SAVE_PRICE[:]\\n del CARDS[:]\",\n \"def del_all(self, items):\\n for item in items:\\n item.key.delete()\\n logger.debug(\\\"Deleted all the items\\\")\",\n \"def delete(self, key):\",\n \"def eliminate_key (self,key):\\r\\n\\r\\n if self.using_shelf:\\r\\n\\r\\n del self.key_dict[str(key)]\",\n \"def delete_many(self, keys):\\n try:\\n if keys:\\n self._cache.delete(*map(self.prepare_key, keys))\\n except Exception as err:\\n return self.warn_or_error(err)\",\n \"def delete_key_HELPER(data_dict, key_list, key_to_delete):\\n data_dict = get_key_from_dict_HELPER(data_dict, key_list[:-1])\\n data_dict.pop(key_to_delete)\\n return data_dict\",\n \"def delete(\\n self, keys: Optional[Iterable[Text]] = None\\n ) -> Dict[Text, StateDictInterface]:\\n records = self.execute()\\n assert isinstance(records, dict)\\n\\n self.store.delete_many(records.values(), keys=keys)\\n return records\",\n \"def _remove_swarm_keys(self):\\n for key in SWARM_PROPERTIES:\\n self.spec.pop(key, None)\",\n \"def clearStore(self):\\n os.remove(self.uid+\\\".pcl\\\")\\n self.items = []\",\n \"def delete_many(self, *keys):\\n self.collection.remove({'_id': {'$in': keys}})\\n return True\",\n \"def remove(self, key):\\n pass\",\n \"def clear_all(self):\\n for key in list(self.keys):\\n os.remove(self._get_path(key))\\n self.keys.remove(key)\",\n \"def removeKeys(self, attributeIndex, view) -> None:\\n ...\",\n \"def _remove_certs_keys(self, cert_list): # pylint: disable=no-self-use\\n # This must occur first, LIST is the official key\\n self._remove_certs_from_list(cert_list)\\n\\n # Remove files\\n for cert in cert_list:\\n os.remove(cert.backup_path)\\n os.remove(cert.backup_key_path)\",\n \"def delete(cls, *keys):\\n todelete = []\\n namespace, kind, member = Schema.Get(cls)\\n for key in keys:\\n assert isinstance(key, str)\\n todelete.append(Key(namespace, kind, key)) \\n Lisa.delete(*todelete)\",\n \"def __delitem__(self, key: tuple):\\n s, a = key\\n del self.store[s][a]\",\n \"def keep_in_dictionary(self,dictionary,*keys):\\r\\n remove_keys = [k for k in dictionary if k not in keys]\\r\\n self.remove_from_dictionary(dictionary,*remove_keys)\",\n \"def clearKeys(self):\\n for attr in self._filter():\\n pm.cutKey(attr)\",\n \"def purge(self):\\n keys = [k for (k, v) in self.get_range()]\\n\\n [self.remove(k) for k in keys]\",\n \"def remove_keys(d, keys):\\n pp = deepcopy(d)\\n if isinstance(keys, (list, tuple)):\\n for k in keys:\\n pp.pop(k, None)\\n else:\\n pp.pop(keys, None)\\n return pp\",\n \"def remove(self, key: int) -> None:\\n t = key % 20011\\n delete = []\\n for item in self.hash[t]:\\n if item[0] == key:\\n delete = item\\n if delete:\\n self.hash[t].remove(delete)\",\n \"def __delitem__(self, key):\\n\\t\\tdel self.__dStore[key]\",\n \"def __delitem__(self, key):\\n del self.list[key]\",\n \"def __delitem__(self, key: Union[Hashable, Sequence[Hashable]]) -> None:\\n self.contents = {i: self.contents[i] for i in self.contents \\n if i not in more_itertools.always_iterable(key)}\\n return\",\n \"def remove(self, key):\\n if key in self._store:\\n del self._store[key]\",\n \"def delete(cls, keys, pipe=None):\\n with cls._pipe(pipe) as pipe:\\n core = cls.core(pipe)\\n core.delete(*keys)\",\n \"def clear(self):\\n for key in self.keys():\\n del self[key]\",\n \"def del_seqs(self, keys):\\n for j in range(len(keys)):\\n del self._d_seqs[keys[j]]\\n self._num_seqs = int(len(self._d_seqs))\\n self._d_seqs = self._d_seqs\\n self._seqs = list(self._d_seqs)\",\n \"def strip_key_strings(po):\\r\\n newlist = [entry for entry in po if not is_key_string(entry.msgid)]\\r\\n del po[:]\\r\\n po += newlist\",\n \"def __delitem__(self, key):\\n self.f_remove(key)\",\n \"def prune_option_list(opts, keys):\\n opt_d = opt_to_dict(opts)\\n for k in keys:\\n if k in opt_d:\\n del opt_d[k]\\n return [k for item in opt_d.iteritems() for k in item]\",\n \"def invalidate_keys(self, keys):\\r\\n if not keys:\\r\\n return\\r\\n flush, flush_keys = self.find_flush_lists(keys)\\r\\n\\r\\n if flush:\\r\\n cache.delete_many(flush)\\r\\n if flush_keys:\\r\\n self.clear_flush_lists(flush_keys)\",\n \"def clear():\\n global d\\n for key in d.keys():\\n del d[key]\",\n \"def prune(self): # HashMap.prune\\n for hashval, list in self.contentHash.iteritems():\\n newlist=[]\\n for entry in list:\\n if not entry.deleted:\\n newlist.append(entry)\\n self.contentHash[hashval]=newlist\",\n \"def dal_delete(key):\\n global store\\n return store.delete(urllib.quote(key))\",\n \"def delete(self, key):\\n pass\",\n \"def delete(self, key):\\n pass\",\n \"def remove(self):\\n for db in self.values():\\n db.remove()\",\n \"def remove(self, key_name: str):\\n pass\",\n \"def test_remove_multiple_key(self):\\n\\n expected = {\\n \\\"Hello\\\": \\\"world\\\",\\n \\\"World\\\": {\\\"world\\\": \\\"hello\\\"},\\n \\\"pyfunceble\\\": [\\\"funilrys\\\"],\\n }\\n\\n actual = Dict(self.test_subject).remove_key([\\\"funilrys\\\", \\\"Py\\\"])\\n\\n self.assertEqual(expected, actual)\",\n \"def without_keys(keys):\\n keys = frozenset(keys) # frozenset has efficient membership lookup\\n return filter_keys_c(fnot(partial(operator.contains, keys)))\",\n \"def _remove_data(things, lst_remove=None):\\n\\n for data in things:\\n data.pop(\\\"_sa_instance_state\\\", None)\\n data.pop(\\\"user_id\\\", None)\\n\\n if lst_remove is not None:\\n for str_remove in lst_remove:\\n if str_remove in data:\\n data.pop(str_remove, None)\\n\\n return things\",\n \"def removeall(self):\\n\\n # If there used to be a key, there must exist an old value blob somewhere in the database. It should be deallocated after a successful commit to disk.\\n for key in self.keys:\\n if self.keys[key] is not None:\\n punchat,punchlen = self.keys[key]\\n self.awaitingpunch.append((punchat, punchlen))\\n \\n self.keys = {}\\n self.buffered = {}\\n self.cache = {}\\n \\n if self.autocommit:\\n commit()\",\n \"async def delete(self, *keys, **kwargs):\\n\\n def gen_keys(keys):\\n all_keys = []\\n for key in keys:\\n if isinstance(key, list):\\n all_keys += gen_keys(keys=key)\\n else:\\n all_keys.append(key)\\n return all_keys\\n\\n all_keys = gen_keys(keys)\\n for key in all_keys:\\n await self._client_conn.hdel(key=self.name, field=key)\",\n \"def remove_all():\\n storage = FileStorage()\\n objects = storage.all()\\n objects = list(objects.values())\\n\\n for element in objects:\\n storage.delete(element)\\n objects = storage.all()\",\n \"def multi_del(self, keys, no_update_log=False):\\n # TODO: write better documentation: why would user need the no_update_log param?\\n opts = (no_update_log and TyrantProtocol.RDBMONOULOG or 0)\\n if not isinstance(keys, (list, tuple)):\\n keys = list(keys)\\n\\n wait(self.proto.misc(\\\"outlist\\\", keys, opts))\",\n \"def flushdb(self):\\n allKeys = self.redis.keys(self.appendKeys(\\\"*\\\"))\\n # for some reason deleteing with a list of keys isn't working\\n p = self.redis.pipeline()\\n for key in allKeys:\\n p.delete(key)\\n p.execute()\",\n \"def remove(self, key):\\n h = key%self.m\\n a = self.a\\n if a[h]:\\n a[h] = None\",\n \"def __delitem__(self, key):\\n pass\",\n \"def __delitem__(self, key):\\n pass\",\n \"def mRemove(self, **kw):\\n kw = copy_non_reserved_keywords(kw)\\n for key, val in kw.items():\\n # It would be easier on the eyes to write this using\\n # \\\"continue\\\" statements whenever we finish processing an item,\\n # but Python 1.5.2 apparently doesn't let you use \\\"continue\\\"\\n # within try:-except: blocks, so we have to nest our code.\\n try:\\n orig = self._dict[key]\\n except KeyError:\\n # No existing variable in the environment, so just skip it\\n pass\\n else:\\n try:\\n # Most straightforward: just try to substract it.\\n # But this will not work in most cases :-(\\n self._dict[key] = orig - val\\n except TypeError:\\n try:\\n # It orig and val is dictionaties:\\n for k in val.keys():\\n del orig[k]\\n # May be some recursion ?\\n except AttributeError:\\n try:\\n # Check if the original is a list.\\n remove_from_orig = orig.remove\\n except AttributeError:\\n # Can't do nothing more\\n pass\\n else:\\n # The original is a list, so remove\\n # value from it.\\n try:\\n i = val[0]\\n except TypeError:\\n val = [ val ]\\n for i in val:\\n try:\\n remove_from_orig(i)\\n except ValueError:\\n pass\\n self.scanner_map_delete(kw)\",\n \"def remove_key(self, key):\\n del self.data[key]\\n self.save_data()\",\n \"def remove(self, *names):\\n for name in names:\\n self._storage.pop(name, None)\",\n \"def discard_index_from_key(self,key,index):\\r\\n\\r\\n # with shelf\\r\\n if self.using_shelf:\\r\\n\\r\\n if key in self.key_dict:\\r\\n\\r\\n self.key_dict[key].discard(str(index))\\r\\n\\r\\n\\r\\n #with database\\r\\n if self.using_database:\\r\\n value_tuple = (notebookname,key,str(index),)\\r\\n db_cursor.execute(\\\"DELETE FROM\\\"\\r\\n +\\\" keys_to_indexes\\\"\\r\\n +\\\" WHERE notebook=?\\\"\\r\\n +\\\" AND keyword=?\\\"\\r\\n +\\\" AND note_index=?;\\\",\\r\\n value_tuple)\\r\\n\\r\\n db_cursor.execute(\\\"SELECT * FROM\\\"\\r\\n +\\\" keys_to_indexes\\\"\\r\\n +\\\" WHERE notebook=?\\\"\\r\\n +\\\" and keyword=?;\\\",\\r\\n value_tuple[0:2])\\r\\n if db_cursor.fetchone():\\r\\n db_cursor.execute(\\\"DELETE FROM\\\"\\r\\n +\\\" all_keys WHERE notebook=?\\\"\\r\\n +\\\" AND keyword=?;\\\",\\r\\n value_tuple[0:2])\",\n \"def removeAll(self):\\n self.pDict.clear()\",\n \"def remove_index_from_key(self,key,index):\\r\\n\\r\\n #with shelf\\r\\n if self.using_shelf:\\r\\n\\r\\n self.key_dict[key].remove(str(index))\\r\\n\\r\\n #with database\\r\\n if self.using_database:\\r\\n value_tuple = (notebookname,key,str(index))\\r\\n db_cursor.execute(\\\"DELETE FROM \\\"\\r\\n +\\\"keys_to_indexes \\\"\\r\\n +\\\"WHERE notebook=? \\\"\\r\\n +\\\"AND keyword=? \\\"\\r\\n +\\\"AND note_index=?;\\\",\\r\\n value_tuple)\\r\\n\\r\\n db_cursor.execute(\\\"SELECT * FROM \\\"\\r\\n +\\\"keys_to_indexes \\\"\\r\\n +\\\"WHERE notebook=? and keyword=?;\\\",\\r\\n value_tuple[0:2])\\r\\n if db_cursor.fetchone():\\r\\n db_cursor.execute(\\\"DELETE FROM \\\"\\r\\n +\\\"all_keys WHERE notebook=? \\\"\\r\\n +\\\"AND keyword=?;\\\",\\r\\n value_tuple[0:2])\",\n \"def delete_many(self, keys, version=None, client=None):\\r\\n\\r\\n if client is None:\\r\\n client = self.get_client(write=True)\\r\\n\\r\\n if not keys:\\r\\n return\\r\\n\\r\\n keys = [self.make_key(k, version=version) for k in keys]\\r\\n try:\\r\\n return client.delete(*keys)\\r\\n except ConnectionError:\\r\\n raise ConnectionInterrupted(connection=client)\",\n \"def __delitem__(self, key):\\n del self._get_storage()[key]\",\n \"def clear(self):\\n self.keyvaluepair_set.all().delete()\",\n \"def __delitem__(self, key):\\n self.delete(key)\",\n \"def __delitem__(self, key):\\n self.delete(key)\",\n \"def remove(self, key: int | str):\\n self.__delitem__(key)\",\n \"def remove(self, key):\\n try:\\n del self._store[key]\\n except KeyError:\\n pass\",\n \"def __delitem__(self, key):\\n self.deleteAttributes([key])\",\n \"def remove():\",\n \"def __delitem__(self, key: tuple):\\n s, a = key\\n if not isinstance(s, self.observation_space) or not isinstance(a, self.action_space):\\n raise KeyError\\n del self.store[s][a]\",\n \"def remove_key(self, key, save_pkl=True):\\r\\n self.keys.remove(key)\\r\\n if save_pkl:\\r\\n self.save_pkl()\",\n \"def remove_keys(_dict, _keys):\\n if isinstance(_keys, str):\\n if _keys in _dict:\\n del _dict[_keys]\\n else:\\n for _key in _keys:\\n _dict = remove_keys(_dict, _key)\\n return _dict\",\n \"def remove_from_kvstore(helper, name, rm_entries, stats):\\n if not rm_entries:\\n return\\n\\n helper.log_info('Removing {0} kvstore entries for MineMeld feed \\\"{1}\\\"'.format(\\n len(rm_entries), name))\\n url = _uri(helper)\\n headers = _headers(helper)\\n\\n # Batch a few at a time, as splunk 414s if the URI is too long, or times\\n # out if it's within the length limits but still hits too many entries to\\n # finish on time. From some tests, it seems like 500 is a good number,\\n # which is nice since it matches the batch_save number.\\n #\\n # The _key field has been 24 characters in length on my system.\\n for i in range(0, len(rm_entries), 500):\\n rms = rm_entries[i:i+500]\\n query = {'$or': list({'_key': x} for x in rms)}\\n resp = helper.send_http_request(\\n url=url,\\n headers=headers,\\n method='DELETE',\\n verify=False,\\n parameters={'query': json.dumps(query)})\\n resp.raise_for_status()\",\n \"def clear(self, lifetime):\\n\\n # find all entries with the specified lifetime\\n to_remove = [k for (k, v) in self.store.items() if v[0] == lifetime]\\n # remove all these entries from the list\\n for t in to_remove:\\n del self.store[t]\",\n \"def remove_data(self, data_keys):\\r\\n self._verify_key_types(name='data', keys=data_keys)\\r\\n if isinstance(data_keys, (str, unicode)):\\r\\n data_keys = [data_keys]\\r\\n for data_key in data_keys:\\r\\n del self[data_key]\",\n \"def delete(self,key):\\n\\n pass\",\n \"def leftdelalllistitems(self):\\n self._leftlist.delete()\",\n \"def __delitem__(self,key):\\n if key in self._register:\\n del self._register[key]\",\n \"def _clean_first_key_from_registry(self):\\n # only clean the first entry from the list\\n to_clean = self._buffered_backend_keys[0]\\n for registry_key in list(self.chunks_registry.keys()):\\n if to_clean in registry_key:\\n del self.chunks_registry[registry_key]\\n del self._buffered_backend_keys[0]\",\n \"def rightdelalllistitems(self):\\n self._rightlist.delete()\",\n \"def test_remove():\\n # remove dict keys\\n schema = Schema({\\\"weight\\\": int,\\n Remove(\\\"color\\\"): str,\\n Remove(\\\"amount\\\"): int})\\n out_ = schema({\\\"weight\\\": 10, \\\"color\\\": \\\"red\\\", \\\"amount\\\": 1})\\n assert \\\"color\\\" not in out_ and \\\"amount\\\" not in out_\\n\\n # remove keys by type\\n schema = Schema({\\\"weight\\\": float,\\n \\\"amount\\\": int,\\n # remvove str keys with int values\\n Remove(str): int,\\n # keep str keys with str values\\n str: str})\\n out_ = schema({\\\"weight\\\": 73.4,\\n \\\"condition\\\": \\\"new\\\",\\n \\\"amount\\\": 5,\\n \\\"left\\\": 2})\\n # amount should stay since it's defined\\n # other string keys with int values will be removed\\n assert \\\"amount\\\" in out_ and \\\"left\\\" not in out_\\n # string keys with string values will stay\\n assert \\\"condition\\\" in out_\\n\\n # remove value from list\\n schema = Schema([Remove(1), int])\\n out_ = schema([1, 2, 3, 4, 1, 5, 6, 1, 1, 1])\\n assert_equal(out_, [2, 3, 4, 5, 6])\\n\\n # remove values from list by type\\n schema = Schema([1.0, Remove(float), int])\\n out_ = schema([1, 2, 1.0, 2.0, 3.0, 4])\\n assert_equal(out_, [1, 2, 1.0, 4])\",\n \"def delete_obsolete_command_items(default, control):\\n delete_keys = []\\n for cmd_id in control:\\n if cmd_id not in default:\\n delete_keys.append(cmd_id)\\n\\n for key in delete_keys:\\n del control[key]\",\n \"def _delKey(self, key):\\n pass\",\n \"def remove(self, key):\\r\\n for i in range(len(self.lis)):\\r\\n if self.lis[i][0] == key:\\r\\n self.lis.pop(i)\\r\\n break\",\n \"def __delitem__(self, key):\\n del self.elements[key]\",\n \"def delete_keys_tags(self,\\r\\n index,\\r\\n deletedkeys):\\r\\n\\r\\n\\r\\n for k_temp in deletedkeys:\\r\\n k_temp = k_temp.strip()\\r\\n if k_temp in set(self.get_keys()):\\r\\n self.discard_index_from_key(k_temp, index)\\r\\n if self.get_indexes_for_key(k_temp) == set():\\r\\n self.eliminate_key(k_temp)\\r\\n for t_temp in self.get_tags():\\r\\n if k_temp in self.get_keys_for_tag(t_temp):\\r\\n self.discard_key_from_tag(t_temp,k_temp)\\r\\n if not self.get_keys_for_tag(t_temp):\\r\\n self.delete_tag(t_temp)\",\n \"def _remove_keys(results: dict, remove: list) -> dict:\\n removed = {}\\n for key, val in results.items():\\n if key not in remove:\\n removed[key] = val\\n return removed\",\n \"def delete(self, *names):\\n\\n return [shard.delete(*keys) for shard, keys\\n in self.gather_keys_by_shard(names)]\",\n \"def middledelalllistitems(self):\\n self._linklist.delete()\",\n \"def discard_key_from_tag(self,tag,key):\\r\\n\\r\\n # with shelf\\r\\n if self.using_shelf:\\r\\n\\r\\n self.tag_dict[tag].discard(key)\\r\\n\\r\\n\\r\\n #with database\\r\\n if self.using_database:\\r\\n value_tuple = (notebookname,tag,key,)\\r\\n db_cursor.execute(\\\"DELETE FROM tags_to_keys\\\"\\r\\n +\\\" WHERE notebook=? AND tag=?\\\"\\r\\n +\\\" AND keyword=?;\\\",\\r\\n value_tuple)\",\n \"def f_remove(self, *args):\\n for arg in args:\\n arg = self.f_translate_key(arg)\\n if arg in self._data:\\n del self._data[arg]\\n else:\\n raise AttributeError(\\n \\\"Your result `%s` does not contain %s.\\\" % (self.name_, arg)\\n )\",\n \"def remove(self, key):\\n match = self.find(key)\\n if not match:\\n raise UserDBValueError(\\\"Element not found in list\\\")\\n\\n self._elements = [this for this in self._elements if this != match]\\n return self\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7374732","0.7209796","0.68456185","0.68456185","0.68456185","0.684242","0.6835356","0.6829273","0.6737269","0.6679472","0.66645175","0.6656001","0.6648994","0.66087186","0.6540633","0.6525455","0.6507897","0.6493868","0.6461113","0.6430038","0.6426386","0.63983876","0.63847756","0.6380733","0.6378122","0.6343758","0.63429433","0.6338155","0.631328","0.6299589","0.62925744","0.62854904","0.6274222","0.6268904","0.6266658","0.62515235","0.61961424","0.618779","0.6167435","0.6157631","0.6147875","0.6147811","0.61447626","0.6137137","0.61328113","0.61153847","0.60999537","0.6083165","0.6083165","0.60811555","0.60765344","0.60676455","0.6062142","0.6061208","0.6055969","0.6039728","0.60330254","0.60323346","0.5989817","0.5984541","0.59808266","0.59808266","0.5977937","0.5974086","0.59596497","0.5954208","0.59518206","0.59493744","0.59481215","0.59471124","0.59377444","0.5934957","0.5934957","0.59300274","0.59268767","0.59238774","0.5921665","0.5913067","0.5899059","0.5890356","0.5888661","0.5880919","0.5879771","0.5876541","0.58525586","0.5835553","0.5832889","0.58088285","0.58087194","0.58078676","0.57948875","0.57904935","0.5787845","0.5780888","0.57775176","0.5776794","0.57758886","0.5773183","0.57721394","0.5761042"],"string":"[\n \"0.7374732\",\n \"0.7209796\",\n \"0.68456185\",\n \"0.68456185\",\n \"0.68456185\",\n \"0.684242\",\n \"0.6835356\",\n \"0.6829273\",\n \"0.6737269\",\n \"0.6679472\",\n \"0.66645175\",\n \"0.6656001\",\n \"0.6648994\",\n \"0.66087186\",\n \"0.6540633\",\n \"0.6525455\",\n \"0.6507897\",\n \"0.6493868\",\n \"0.6461113\",\n \"0.6430038\",\n \"0.6426386\",\n \"0.63983876\",\n \"0.63847756\",\n \"0.6380733\",\n \"0.6378122\",\n \"0.6343758\",\n \"0.63429433\",\n \"0.6338155\",\n \"0.631328\",\n \"0.6299589\",\n \"0.62925744\",\n \"0.62854904\",\n \"0.6274222\",\n \"0.6268904\",\n \"0.6266658\",\n \"0.62515235\",\n \"0.61961424\",\n \"0.618779\",\n \"0.6167435\",\n \"0.6157631\",\n \"0.6147875\",\n \"0.6147811\",\n \"0.61447626\",\n \"0.6137137\",\n \"0.61328113\",\n \"0.61153847\",\n \"0.60999537\",\n \"0.6083165\",\n \"0.6083165\",\n \"0.60811555\",\n \"0.60765344\",\n \"0.60676455\",\n \"0.6062142\",\n \"0.6061208\",\n \"0.6055969\",\n \"0.6039728\",\n \"0.60330254\",\n \"0.60323346\",\n \"0.5989817\",\n \"0.5984541\",\n \"0.59808266\",\n \"0.59808266\",\n \"0.5977937\",\n \"0.5974086\",\n \"0.59596497\",\n \"0.5954208\",\n \"0.59518206\",\n \"0.59493744\",\n \"0.59481215\",\n \"0.59471124\",\n \"0.59377444\",\n \"0.5934957\",\n \"0.5934957\",\n \"0.59300274\",\n \"0.59268767\",\n \"0.59238774\",\n \"0.5921665\",\n \"0.5913067\",\n \"0.5899059\",\n \"0.5890356\",\n \"0.5888661\",\n \"0.5880919\",\n \"0.5879771\",\n \"0.5876541\",\n \"0.58525586\",\n \"0.5835553\",\n \"0.5832889\",\n \"0.58088285\",\n \"0.58087194\",\n \"0.58078676\",\n \"0.57948875\",\n \"0.57904935\",\n \"0.5787845\",\n \"0.5780888\",\n \"0.57775176\",\n \"0.5776794\",\n \"0.57758886\",\n \"0.5773183\",\n \"0.57721394\",\n \"0.5761042\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6642458"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":14880,"cells":{"query":{"kind":"string","value":"Clear the whole store"},"document":{"kind":"string","value":"def clear(self) -> bool:\n raise NotImplementedError('clear must be reimplemented in concrete implementation')"},"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 clear(self) -> None:\n self._store.clear()","def clear(self):\n self._store = {}","def clearStore(self):\n os.remove(self.uid+\".pcl\")\n self.items = []","def clear(self):\n self.tensor_store.clear()\n self.i = 0","def clear(self):\n self._storage.clear()","def clear(self):\n self.db_dict.clear()","def clear(self):\n try:\n self._load(False)\n except KeyError:\n return\n\n for i in xrange(self.size):\n try:\n del self.db[i]\n except KeyError:\n pass\n del self.db['count']\n del self.db['head']\n del self.db['size']","def clear_all(self):\n self.clear_redis()\n self.clear_cache()","def clear(self) -> None:\n self.saved.clear()","def clear(self):\r\n self._state[\"data\"].clear()\r\n self._state[\"session\"].request_rerun()","def clear(self):\r\n self._state[\"data\"].clear()\r\n self._state[\"session\"].request_rerun()","def clear(self):\n self._state[\"data\"].clear()\n self._state[\"session\"].request_rerun()","def clear(self):\n self._state[\"data\"].clear()\n self._state[\"session\"].request_rerun()","def clear(self):\n self._state[\"data\"].clear()\n self._state[\"session\"].request_rerun()","def clear(self) -> None:\n ...","def clear(self):\n for key in self.__data.keys():\n del self.__data[key]","def clear(self) -> None:","def clear(self):\n # Orphan all objects\n for obj in self.uow:\n state(obj).session = None\n self.uow.clear()\n self.imap.clear()","def clear(self):\n self.call('clear')","def clear():\n\t\tModel.counter = 0","def clear_all(self):\n raise NotImplementedError","def clear(self):\n ...","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):\n pass","def clear(self):\n pass","def clear(self):\n pass","def clear():","async def clear_all(self) -> None:","def clear_datastore():\r\n apiproxy_stub_map.apiproxy = apiproxy_stub_map.APIProxyStubMap()\r\n stub = datastore_file_stub.DatastoreFileStub('billkatz-test', '/dev/null', '/dev/null')\r\n apiproxy_stub_map.apiproxy.RegisterStub('datastore_v3', stub)","def devClearStores(self):\n self._impDataIndex = 0\n self.storeTree = MovieStoreTree()\n self.storeHeap = MovieStoreHeap()\n self.storeHash = MovieStoreHash()\n self.benchmarkDisplay.binarySearchTree.set(0)\n self.benchmarkDisplay.binaryHeap.set(0)\n self.benchmarkDisplay.hashTable.set(0)\n self.benchmarkDisplay.binarySearchTreeDepth.set(0)\n self.benchmarkDisplay.binaryHeapDepth.set(0)","def clear(self):\n self.keyvaluepair_set.all().delete()","def clear_storage(self):\r\n raise NotImplementedError('override me')","async def clear(self):","def clear(self):\n self._clear()","def clear(self):\n self._clear()","def clear(self):\n for key in self.keys():\n del self[key]","def Clear(self) -> None:","def clear(self) -> None:\n self.items.all().delete()\n self._cached_items = None","def remove_all():\n \"\"\" Removes all from the database \"\"\"\n redis_store.flushall()","def clear(self):\n if self.debug:\n print(\"DIMS cleared\")\n self.sp_dicts.clear()","def clear_all():\n bpy.ops.object.select_all(action='SELECT')\n bpy.ops.object.delete()","def clear(self) -> None:\n self.objects = []","def clear(self):\n self._data.clear()","def clear():\n MIGRATIONS.clear()","def clear(self) -> None:\n raise NotImplementedError","def clear(self) -> None:\n pass","def clear(self):\n self.journal = Journal()","def clear(self):\n self.history.clear()","def delete_all(self):\n with self.__lock:\n self.__data = dict()\n self.flush()","def remove_all_recs(self):\n return self.storage.clear()","def clear_all(self):\n self._data = {}\n self.uncache()\n self.dirty = True\n self.shipping_method = None\n self.payment_method = None\n self.customer_comment = \"\"","def clear(self):\n raise NotImplementedError","def clear(self):\r\n for key in self.conn.keys():\r\n self.conn.delete(key)","def clear(self):\n self._pkcache = {}\n self._typecache = defaultdict(dict)\n self.init()","def clear(self):\n Library.functions.clear(self._book)","def clear(self):\n self._list.clear()","def clear_db(db : Session = Depends(get_db)):\n db.query(Acti).delete()\n db.query(Wrist).delete()\n db.commit()","def clear_all(self):\n for key in list(self.keys):\n os.remove(self._get_path(key))\n self.keys.remove(key)","def clear_data(self):\n if isinstance(self.data, DataManager):\n self.data._update_keys(clear=True)\n else:\n self.data = {}","def clear(self):\r\n # Remove all Currency from the handler's parent object.\r\n for currency in self.all:\r\n self.remove(currency)","def clear(self):\n self.__dict__.clear()","def clearRecord(self): \n if self._isinstalled:\n for f in self._table:\n try:\n del self.__dict__[f.name]\n except KeyError:\n pass\n \n for f in self._extra_sql_columns:\n try:\n del self.__dict__[f]\n except KeyError:\n pass\n \n self._original_values.clear()\n self._modified_values.clear()\n self._mtm_referencelist.clear()\n self._child_referencelist.clear()\n self._hasdata = False\n self._ismodified = False\n self._hasdata = False\n self._isnew = False\n self._objectid = None\n self._isinstalled = False\n self._astxt = \"(null)\"","def clear(self):\r\n self.orderitem_set.all().delete()","def clear(self):\n try:\n self._cache.flushdb()\n except Exception as err:\n return self.warn_or_error(err)","def _data_reset(self):\n conn = self.get_connection()\n\n elements = {\n **self.domain.registry.aggregates,\n **self.domain.registry.entities,\n **self.domain.registry.views,\n }\n for _, element_record in elements.items():\n provider = current_domain.providers[element_record.cls.meta_.provider]\n repo = self.domain.repository_for(element_record.cls)\n\n model_cls = repo._model\n if provider.conn_info[\n \"DATABASE\"\n ] == Database.ELASTICSEARCH.value and conn.indices.exists(\n model_cls._index._name\n ):\n conn.delete_by_query(\n refresh=True,\n index=model_cls._index._name,\n body={\"query\": {\"match_all\": {}}},\n )","def clear(self):\n self._entries.clear()","def clear(self, name=None):\n if name is None: # Delete whole cache\n try:\n os.unlink(self.filepath)\n except OSError:\n pass\n return\n elif name in self.caches:\n sql = u'DROP TABLE `{}`'.format(name)\n with self.conn as c:\n c.execute(sql)\n return\n else:\n raise ValueError('store not found : {!r}'.format(name))","def clear(self):\n del self._record_list[:]\n self._number = 0","def clear_existing_modulestores():\r\n _MODULESTORES.clear()\r\n # pylint: disable=W0603\r\n global _loc_singleton\r\n cache = getattr(_loc_singleton, \"cache\", None)\r\n if cache:\r\n cache.clear()\r\n _loc_singleton = None","def clear_db(self):\n self.cursor.execute(\"DELETE FROM TrackPoint\")\n self.cursor.execute(\"DELETE FROM Activity\")\n self.cursor.execute(\"DELETE FROM User\")\n self.db_connection.commit()","def clear(self):\n raise NotImplementedError()","def clear(cls):\n\n db = get_db_handle()\n for secret in db.secret_table.select():\n secret.delete_instance(recursive=True)","def reset(self):\n self._execute(\"DELETE FROM collection_table\")\n self._execute(\"DELETE FROM keyword_table\")","def clear(self):\n cursor = self._dbcon.cursor()\n cursor.execute(u\"delete from books\")\n self._dbcon.commit()\n cursor.close()","def clear(self):\n self.collection.drop()\n return True","def clear(self, clearall=False):\n def closure(cur):\n cur.execute(\"\"\"\n DELETE FROM events\n \"\"\")\n if clearall:\n cur.execute(\"\"\"\n DELETE FROM slides\n \"\"\")\n cur.execute(\"\"\"\n DELETE FROM rooms\n \"\"\")\n self.execute(closure)","def clear_cache(self):\n self.mongo_database.cache.delete_many({})","def clear(self):\n\n self.size = 0\n\n self.table = [[]] * 100\n\n self.keys_set = set()\n\n self.keys_ref = [[]] * 100","def purge_cache(self):\n\n self.local_store.purge_cache()","def reset(self):\n reset_query = \"DELETE * FROM %s\" % MediaCollection.COLLECTIONS_TABLE\n self.cursor.execute(reset_query)","def clear(self):\n self._clear()\n self._update()","def clear(self, lifetime):\n\n # find all entries with the specified lifetime\n to_remove = [k for (k, v) in self.store.items() if v[0] == lifetime]\n # remove all these entries from the list\n for t in to_remove:\n del self.store[t]","def clear(self):\n self._in_memory_objects.clear()\n self._disk_objects.clear()\n self._object_to_list_node.clear()\n for bucket in self._buckets:\n bucket.clear()","def clear(self):\n self.initialize()\n self.device_disconnect()","def clear(self):\n try:\n i = self.db[self._headKey]\n except KeyError:\n # nothing to delete\n return\n\n while i:\n # Save the next key first\n try:\n next = self.db[self._getNextKey(i)]\n except KeyError:\n next = None\n self.remove(i)\n i = next","def clear(cls)->None:\n database.cursor.execute(\"DELETE FROM {}\".format(cls.table_name))\n database.connection.commit()","def test_005_clear(self):\n HEADING()\n db = self.db\n db.connect()\n\n db.clear()\n\n # assert not os.path.isfile(path_expand(\"~/.cloudmesh/pbs/pbs.db\"))\n assert(len(db) == 0)","def clear_db():\n from example_data import ExampleDataLoader\n ExampleDataLoader.clean_db()","def clearAllSettings(self) -> None:\n ...","def clear(self):\r\n del self.__config\r\n self.__config = {}\r\n self.save()","def clear_redis(self):\n self.redis_conn.flushall()","def clear_data():\n conn = get_connect()\n #conn.execute(\"DELETE from match\")\n #conn.execute(\"DELETE from account\")\n #conn.execute(\"DELETE from championMatchData\")\n conn.execute(\"DELETE from championData\")\n conn.commit()\n conn.close()\n print(\"all data in info.db has been cleared\")\n return","def clearmodels(self):\n \n dbpath, config = self._start() \n ModelDescriptionTable(dbpath).empty()\n ModelPhenotypeTable(dbpath).empty()\n ModelScoreTable(dbpath).empty() \n self._end()","def clear(self) -> None:\n self._updates.clear()\n self._fragments.clear()\n self._initialized = False # next access should reload all fragments","def clear(self):\n pass"],"string":"[\n \"def clear(self) -> None:\\n self._store.clear()\",\n \"def clear(self):\\n self._store = {}\",\n \"def clearStore(self):\\n os.remove(self.uid+\\\".pcl\\\")\\n self.items = []\",\n \"def clear(self):\\n self.tensor_store.clear()\\n self.i = 0\",\n \"def clear(self):\\n self._storage.clear()\",\n \"def clear(self):\\n self.db_dict.clear()\",\n \"def clear(self):\\n try:\\n self._load(False)\\n except KeyError:\\n return\\n\\n for i in xrange(self.size):\\n try:\\n del self.db[i]\\n except KeyError:\\n pass\\n del self.db['count']\\n del self.db['head']\\n del self.db['size']\",\n \"def clear_all(self):\\n self.clear_redis()\\n self.clear_cache()\",\n \"def clear(self) -> None:\\n self.saved.clear()\",\n \"def clear(self):\\r\\n self._state[\\\"data\\\"].clear()\\r\\n self._state[\\\"session\\\"].request_rerun()\",\n \"def clear(self):\\r\\n self._state[\\\"data\\\"].clear()\\r\\n self._state[\\\"session\\\"].request_rerun()\",\n \"def clear(self):\\n self._state[\\\"data\\\"].clear()\\n self._state[\\\"session\\\"].request_rerun()\",\n \"def clear(self):\\n self._state[\\\"data\\\"].clear()\\n self._state[\\\"session\\\"].request_rerun()\",\n \"def clear(self):\\n self._state[\\\"data\\\"].clear()\\n self._state[\\\"session\\\"].request_rerun()\",\n \"def clear(self) -> None:\\n ...\",\n \"def clear(self):\\n for key in self.__data.keys():\\n del self.__data[key]\",\n \"def clear(self) -> None:\",\n \"def clear(self):\\n # Orphan all objects\\n for obj in self.uow:\\n state(obj).session = None\\n self.uow.clear()\\n self.imap.clear()\",\n \"def clear(self):\\n self.call('clear')\",\n \"def clear():\\n\\t\\tModel.counter = 0\",\n \"def clear_all(self):\\n raise NotImplementedError\",\n \"def clear(self):\\n ...\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\\n pass\",\n \"def clear(self):\\n pass\",\n \"def clear(self):\\n pass\",\n \"def clear():\",\n \"async def clear_all(self) -> None:\",\n \"def clear_datastore():\\r\\n apiproxy_stub_map.apiproxy = apiproxy_stub_map.APIProxyStubMap()\\r\\n stub = datastore_file_stub.DatastoreFileStub('billkatz-test', '/dev/null', '/dev/null')\\r\\n apiproxy_stub_map.apiproxy.RegisterStub('datastore_v3', stub)\",\n \"def devClearStores(self):\\n self._impDataIndex = 0\\n self.storeTree = MovieStoreTree()\\n self.storeHeap = MovieStoreHeap()\\n self.storeHash = MovieStoreHash()\\n self.benchmarkDisplay.binarySearchTree.set(0)\\n self.benchmarkDisplay.binaryHeap.set(0)\\n self.benchmarkDisplay.hashTable.set(0)\\n self.benchmarkDisplay.binarySearchTreeDepth.set(0)\\n self.benchmarkDisplay.binaryHeapDepth.set(0)\",\n \"def clear(self):\\n self.keyvaluepair_set.all().delete()\",\n \"def clear_storage(self):\\r\\n raise NotImplementedError('override me')\",\n \"async def clear(self):\",\n \"def clear(self):\\n self._clear()\",\n \"def clear(self):\\n self._clear()\",\n \"def clear(self):\\n for key in self.keys():\\n del self[key]\",\n \"def Clear(self) -> None:\",\n \"def clear(self) -> None:\\n self.items.all().delete()\\n self._cached_items = None\",\n \"def remove_all():\\n \\\"\\\"\\\" Removes all from the database \\\"\\\"\\\"\\n redis_store.flushall()\",\n \"def clear(self):\\n if self.debug:\\n print(\\\"DIMS cleared\\\")\\n self.sp_dicts.clear()\",\n \"def clear_all():\\n bpy.ops.object.select_all(action='SELECT')\\n bpy.ops.object.delete()\",\n \"def clear(self) -> None:\\n self.objects = []\",\n \"def clear(self):\\n self._data.clear()\",\n \"def clear():\\n MIGRATIONS.clear()\",\n \"def clear(self) -> None:\\n raise NotImplementedError\",\n \"def clear(self) -> None:\\n pass\",\n \"def clear(self):\\n self.journal = Journal()\",\n \"def clear(self):\\n self.history.clear()\",\n \"def delete_all(self):\\n with self.__lock:\\n self.__data = dict()\\n self.flush()\",\n \"def remove_all_recs(self):\\n return self.storage.clear()\",\n \"def clear_all(self):\\n self._data = {}\\n self.uncache()\\n self.dirty = True\\n self.shipping_method = None\\n self.payment_method = None\\n self.customer_comment = \\\"\\\"\",\n \"def clear(self):\\n raise NotImplementedError\",\n \"def clear(self):\\r\\n for key in self.conn.keys():\\r\\n self.conn.delete(key)\",\n \"def clear(self):\\n self._pkcache = {}\\n self._typecache = defaultdict(dict)\\n self.init()\",\n \"def clear(self):\\n Library.functions.clear(self._book)\",\n \"def clear(self):\\n self._list.clear()\",\n \"def clear_db(db : Session = Depends(get_db)):\\n db.query(Acti).delete()\\n db.query(Wrist).delete()\\n db.commit()\",\n \"def clear_all(self):\\n for key in list(self.keys):\\n os.remove(self._get_path(key))\\n self.keys.remove(key)\",\n \"def clear_data(self):\\n if isinstance(self.data, DataManager):\\n self.data._update_keys(clear=True)\\n else:\\n self.data = {}\",\n \"def clear(self):\\r\\n # Remove all Currency from the handler's parent object.\\r\\n for currency in self.all:\\r\\n self.remove(currency)\",\n \"def clear(self):\\n self.__dict__.clear()\",\n \"def clearRecord(self): \\n if self._isinstalled:\\n for f in self._table:\\n try:\\n del self.__dict__[f.name]\\n except KeyError:\\n pass\\n \\n for f in self._extra_sql_columns:\\n try:\\n del self.__dict__[f]\\n except KeyError:\\n pass\\n \\n self._original_values.clear()\\n self._modified_values.clear()\\n self._mtm_referencelist.clear()\\n self._child_referencelist.clear()\\n self._hasdata = False\\n self._ismodified = False\\n self._hasdata = False\\n self._isnew = False\\n self._objectid = None\\n self._isinstalled = False\\n self._astxt = \\\"(null)\\\"\",\n \"def clear(self):\\r\\n self.orderitem_set.all().delete()\",\n \"def clear(self):\\n try:\\n self._cache.flushdb()\\n except Exception as err:\\n return self.warn_or_error(err)\",\n \"def _data_reset(self):\\n conn = self.get_connection()\\n\\n elements = {\\n **self.domain.registry.aggregates,\\n **self.domain.registry.entities,\\n **self.domain.registry.views,\\n }\\n for _, element_record in elements.items():\\n provider = current_domain.providers[element_record.cls.meta_.provider]\\n repo = self.domain.repository_for(element_record.cls)\\n\\n model_cls = repo._model\\n if provider.conn_info[\\n \\\"DATABASE\\\"\\n ] == Database.ELASTICSEARCH.value and conn.indices.exists(\\n model_cls._index._name\\n ):\\n conn.delete_by_query(\\n refresh=True,\\n index=model_cls._index._name,\\n body={\\\"query\\\": {\\\"match_all\\\": {}}},\\n )\",\n \"def clear(self):\\n self._entries.clear()\",\n \"def clear(self, name=None):\\n if name is None: # Delete whole cache\\n try:\\n os.unlink(self.filepath)\\n except OSError:\\n pass\\n return\\n elif name in self.caches:\\n sql = u'DROP TABLE `{}`'.format(name)\\n with self.conn as c:\\n c.execute(sql)\\n return\\n else:\\n raise ValueError('store not found : {!r}'.format(name))\",\n \"def clear(self):\\n del self._record_list[:]\\n self._number = 0\",\n \"def clear_existing_modulestores():\\r\\n _MODULESTORES.clear()\\r\\n # pylint: disable=W0603\\r\\n global _loc_singleton\\r\\n cache = getattr(_loc_singleton, \\\"cache\\\", None)\\r\\n if cache:\\r\\n cache.clear()\\r\\n _loc_singleton = None\",\n \"def clear_db(self):\\n self.cursor.execute(\\\"DELETE FROM TrackPoint\\\")\\n self.cursor.execute(\\\"DELETE FROM Activity\\\")\\n self.cursor.execute(\\\"DELETE FROM User\\\")\\n self.db_connection.commit()\",\n \"def clear(self):\\n raise NotImplementedError()\",\n \"def clear(cls):\\n\\n db = get_db_handle()\\n for secret in db.secret_table.select():\\n secret.delete_instance(recursive=True)\",\n \"def reset(self):\\n self._execute(\\\"DELETE FROM collection_table\\\")\\n self._execute(\\\"DELETE FROM keyword_table\\\")\",\n \"def clear(self):\\n cursor = self._dbcon.cursor()\\n cursor.execute(u\\\"delete from books\\\")\\n self._dbcon.commit()\\n cursor.close()\",\n \"def clear(self):\\n self.collection.drop()\\n return True\",\n \"def clear(self, clearall=False):\\n def closure(cur):\\n cur.execute(\\\"\\\"\\\"\\n DELETE FROM events\\n \\\"\\\"\\\")\\n if clearall:\\n cur.execute(\\\"\\\"\\\"\\n DELETE FROM slides\\n \\\"\\\"\\\")\\n cur.execute(\\\"\\\"\\\"\\n DELETE FROM rooms\\n \\\"\\\"\\\")\\n self.execute(closure)\",\n \"def clear_cache(self):\\n self.mongo_database.cache.delete_many({})\",\n \"def clear(self):\\n\\n self.size = 0\\n\\n self.table = [[]] * 100\\n\\n self.keys_set = set()\\n\\n self.keys_ref = [[]] * 100\",\n \"def purge_cache(self):\\n\\n self.local_store.purge_cache()\",\n \"def reset(self):\\n reset_query = \\\"DELETE * FROM %s\\\" % MediaCollection.COLLECTIONS_TABLE\\n self.cursor.execute(reset_query)\",\n \"def clear(self):\\n self._clear()\\n self._update()\",\n \"def clear(self, lifetime):\\n\\n # find all entries with the specified lifetime\\n to_remove = [k for (k, v) in self.store.items() if v[0] == lifetime]\\n # remove all these entries from the list\\n for t in to_remove:\\n del self.store[t]\",\n \"def clear(self):\\n self._in_memory_objects.clear()\\n self._disk_objects.clear()\\n self._object_to_list_node.clear()\\n for bucket in self._buckets:\\n bucket.clear()\",\n \"def clear(self):\\n self.initialize()\\n self.device_disconnect()\",\n \"def clear(self):\\n try:\\n i = self.db[self._headKey]\\n except KeyError:\\n # nothing to delete\\n return\\n\\n while i:\\n # Save the next key first\\n try:\\n next = self.db[self._getNextKey(i)]\\n except KeyError:\\n next = None\\n self.remove(i)\\n i = next\",\n \"def clear(cls)->None:\\n database.cursor.execute(\\\"DELETE FROM {}\\\".format(cls.table_name))\\n database.connection.commit()\",\n \"def test_005_clear(self):\\n HEADING()\\n db = self.db\\n db.connect()\\n\\n db.clear()\\n\\n # assert not os.path.isfile(path_expand(\\\"~/.cloudmesh/pbs/pbs.db\\\"))\\n assert(len(db) == 0)\",\n \"def clear_db():\\n from example_data import ExampleDataLoader\\n ExampleDataLoader.clean_db()\",\n \"def clearAllSettings(self) -> None:\\n ...\",\n \"def clear(self):\\r\\n del self.__config\\r\\n self.__config = {}\\r\\n self.save()\",\n \"def clear_redis(self):\\n self.redis_conn.flushall()\",\n \"def clear_data():\\n conn = get_connect()\\n #conn.execute(\\\"DELETE from match\\\")\\n #conn.execute(\\\"DELETE from account\\\")\\n #conn.execute(\\\"DELETE from championMatchData\\\")\\n conn.execute(\\\"DELETE from championData\\\")\\n conn.commit()\\n conn.close()\\n print(\\\"all data in info.db has been cleared\\\")\\n return\",\n \"def clearmodels(self):\\n \\n dbpath, config = self._start() \\n ModelDescriptionTable(dbpath).empty()\\n ModelPhenotypeTable(dbpath).empty()\\n ModelScoreTable(dbpath).empty() \\n self._end()\",\n \"def clear(self) -> None:\\n self._updates.clear()\\n self._fragments.clear()\\n self._initialized = False # next access should reload all fragments\",\n \"def clear(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.86360115","0.8251459","0.8168097","0.76454467","0.754934","0.7438981","0.7416115","0.7318606","0.7248102","0.7210689","0.7210689","0.7209975","0.7209975","0.7209975","0.7167617","0.71544695","0.714768","0.71438867","0.7102816","0.71001446","0.70647645","0.7059654","0.7036528","0.7036528","0.7036528","0.7036528","0.7036528","0.7036528","0.7036528","0.7032516","0.7032516","0.7032516","0.70275944","0.70189154","0.70107186","0.6978512","0.6956398","0.6945059","0.6930244","0.6926423","0.6926423","0.69261444","0.6916906","0.69160664","0.691248","0.6853436","0.6851159","0.68347764","0.68214196","0.6803517","0.6780336","0.67788804","0.67706394","0.6762029","0.6760977","0.6759269","0.6758517","0.6754316","0.6746041","0.6745683","0.6741101","0.6739663","0.6719312","0.6718308","0.6707637","0.66990006","0.66933775","0.66871977","0.66836697","0.6683175","0.66803664","0.6679222","0.6668529","0.6664214","0.6663651","0.666332","0.66583717","0.6657686","0.66499454","0.66476095","0.6646345","0.66383696","0.66363484","0.66285306","0.66170007","0.6616885","0.66152143","0.66086864","0.66009676","0.6590667","0.65905493","0.65883476","0.65837705","0.6583267","0.6581968","0.6579656","0.65736514","0.6572573","0.6561424","0.6559465","0.65559787"],"string":"[\n \"0.86360115\",\n \"0.8251459\",\n \"0.8168097\",\n \"0.76454467\",\n \"0.754934\",\n \"0.7438981\",\n \"0.7416115\",\n \"0.7318606\",\n \"0.7248102\",\n \"0.7210689\",\n \"0.7210689\",\n \"0.7209975\",\n \"0.7209975\",\n \"0.7209975\",\n \"0.7167617\",\n \"0.71544695\",\n \"0.714768\",\n \"0.71438867\",\n \"0.7102816\",\n \"0.71001446\",\n \"0.70647645\",\n \"0.7059654\",\n \"0.7036528\",\n \"0.7036528\",\n \"0.7036528\",\n \"0.7036528\",\n \"0.7036528\",\n \"0.7036528\",\n \"0.7036528\",\n \"0.7032516\",\n \"0.7032516\",\n \"0.7032516\",\n \"0.70275944\",\n \"0.70189154\",\n \"0.70107186\",\n \"0.6978512\",\n \"0.6956398\",\n \"0.6945059\",\n \"0.6930244\",\n \"0.6926423\",\n \"0.6926423\",\n \"0.69261444\",\n \"0.6916906\",\n \"0.69160664\",\n \"0.691248\",\n \"0.6853436\",\n \"0.6851159\",\n \"0.68347764\",\n \"0.68214196\",\n \"0.6803517\",\n \"0.6780336\",\n \"0.67788804\",\n \"0.67706394\",\n \"0.6762029\",\n \"0.6760977\",\n \"0.6759269\",\n \"0.6758517\",\n \"0.6754316\",\n \"0.6746041\",\n \"0.6745683\",\n \"0.6741101\",\n \"0.6739663\",\n \"0.6719312\",\n \"0.6718308\",\n \"0.6707637\",\n \"0.66990006\",\n \"0.66933775\",\n \"0.66871977\",\n \"0.66836697\",\n \"0.6683175\",\n \"0.66803664\",\n \"0.6679222\",\n \"0.6668529\",\n \"0.6664214\",\n \"0.6663651\",\n \"0.666332\",\n \"0.66583717\",\n \"0.6657686\",\n \"0.66499454\",\n \"0.66476095\",\n \"0.6646345\",\n \"0.66383696\",\n \"0.66363484\",\n \"0.66285306\",\n \"0.66170007\",\n \"0.6616885\",\n \"0.66152143\",\n \"0.66086864\",\n \"0.66009676\",\n \"0.6590667\",\n \"0.65905493\",\n \"0.65883476\",\n \"0.65837705\",\n \"0.6583267\",\n \"0.6581968\",\n \"0.6579656\",\n \"0.65736514\",\n \"0.6572573\",\n \"0.6561424\",\n \"0.6559465\",\n \"0.65559787\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14881,"cells":{"query":{"kind":"string","value":"Get a bunch of keys either from the cache layer or from the base"},"document":{"kind":"string","value":"def mget(self, keys: List[K]) -> List[Optional[V]]:\n # Note an explicit check for None, because falsy values can be valid keys\n valid_index_and_key_list = [(idx, key) for idx, key in enumerate(keys) if key is not None]\n # Initialize the results\n results = [None] * len(keys)\n\n if valid_index_and_key_list:\n # Split indices and keys into separate lists\n valid_keys = [ik[1] for ik in valid_index_and_key_list]\n # Keep track of which indices were not hit in the cache\n missed_index_and_key_list = []\n layer_hits = self._layer.mget(valid_keys)\n for layer_hit, index_and_key in zip(layer_hits, valid_index_and_key_list):\n if layer_hit is None:\n missed_index_and_key_list.append(index_and_key)\n else:\n results[index_and_key[0]] = layer_hit\n\n if missed_index_and_key_list:\n missed_keys = [ik[1] for ik in missed_index_and_key_list]\n base_hits = self._base.mget(missed_keys)\n\n mapping_to_write = {}\n for base_hit, index_and_key in zip(base_hits, missed_index_and_key_list):\n if base_hit:\n results[index_and_key[0]] = base_hit\n mapping_to_write[index_and_key[1]] = base_hit\n\n self._layer.mset(mapping_to_write)\n\n return results"},"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":["async def _multi_get(self, keys, encoding=\"utf-8\"):\n return [SimpleMemoryBackend._cache.get(key) for key in keys]","def keys_fetch(self):\n with self.env.begin(write=False) as txn:\n cursor = txn.cursor()\n tot = txn.stat()['entries']\n i = 0\n\n path = self.db_path\n base_name = self.base_path\n cache_file_path = os.path.join(path, '_cache_' + base_name + '.pkl')\n print('cache_file_path = ', cache_file_path) # DEBUG\n\n if os.path.isfile(cache_file_path):\n self.keys = pickle.load(open(cache_file_path, 'rb'))\n self._num_examples = tot\n else:\n keys = []\n for key, _ in cursor:\n i += 1\n if i % 1000 == 0 or i == tot:\n print('Fetching {:>8d} /{:>8d} keys'.format(i, tot),\n end='\\r')\n keys.append(key)\n print('\\nDone.')\n self._num_examples = tot\n self.keys = np.asarray(keys)\n pickle.dump(self.keys, open(cache_file_path, 'wb'))","def keysAll():","def fetch_objects(cache_key_f, get_database_f, item_keys):\r\n item_key_to_item = get_many_by_key(cache_key_f, item_keys)\r\n \r\n for item_key in item_keys:\r\n if item_key not in item_key_to_item:\r\n # failed to get the item from the cache\r\n try:\r\n # have to get each item individually to cache the query\r\n item = get_database_f(item_key)\r\n item_key_to_item[item_key] = item\r\n except ObjectDoesNotExist:\r\n pass\r\n \r\n return item_key_to_item","def findall(self, key_list):\n for i in range(3):\n try:\n return self.redis_handler.mget(key_list) \n except:\n continue","def all_keys(self):\n return self.derivable_keys() + self.loadable_keys()","def get(self, key: Any, **kwargs) -> Iterable:\n return self.store.get(key, **kwargs)","def get_many_by_key(cache_key_f, item_keys, version=None):\r\n cache_key_to_item_key = {}\r\n for item_key in item_keys:\r\n cache_key = cache.make_key(cache_key_f(item_key), version=version)\r\n cache_key_to_item_key[cache_key] = item_key\r\n\r\n # request from cache\r\n from_cache = cache.get_many(cache_key_to_item_key.keys())\r\n\r\n results = {}\r\n for cache_key, value in from_cache.iteritems():\r\n item_key = cache_key_to_item_key[cache_key]\r\n results[item_key] = value\r\n return results","def keys(self, key=None, lo=None, hi=None, reverse=None, max=None,\n include=False, txn=None, rec=None):\n return itertools.imap(ITEMGETTER_0,\n self.items(key, lo, hi, reverse, max, include, txn, rec))","def _get_keys(self, listOfKeys):\n return self._keys","def get_many(self, keys, default=None):\n raise NotImplementedError()","def keys(self, args=None, lo=None, hi=None, reverse=None, max=None,\n include=False, txn=None):\n return itertools.imap(ITEMGETTER_1,\n self.pairs(args, lo, hi, reverse, max, include, txn))","async def get_all(self, key: datastore.Key) -> RV:\n\t\treturn await (await self.get(key)).collect() # type: ignore[return-value]","def ikeys(self, prefix=''):","def multiget(self, keys):\n return self.sp.multiget(keys)","def keys():","def cache_key(self):","def get_keys(self):\r\n\t\tlogger.debug(\"Getting the keys\")\r\n\t\t\r\n\t\treturn db.get_items('keys')","def get_key_set():\n keys = [0] * n_families\n for i in range(n_families):\n keys[i] = get_key(i)\n\n return keys","def keys(self, **kwargs) -> Iterable:\n return self.store.keys(**kwargs)","def get_bulk(\n self,\n keys: Collection[KT],\n callback: Optional[Callable[[], None]] = None,\n ) -> Tuple[Dict[KT, VT], Optional[\"defer.Deferred[Dict[KT, VT]]\"], Collection[KT]]:\n\n # The cached results\n cached = {}\n\n # List of pending deferreds\n pending = []\n\n # Dict that gets filled out when the pending deferreds complete\n pending_results = {}\n\n # List of keys that aren't in either cache\n missing = []\n\n callbacks = (callback,) if callback else ()\n\n for key in keys:\n # Check if its in the main cache.\n immediate_value = self.cache.get(\n key,\n _Sentinel.sentinel,\n callbacks=callbacks,\n )\n if immediate_value is not _Sentinel.sentinel:\n cached[key] = immediate_value\n continue\n\n # Check if its in the pending cache\n pending_value = self._pending_deferred_cache.get(key, _Sentinel.sentinel)\n if pending_value is not _Sentinel.sentinel:\n pending_value.add_invalidation_callback(key, callback)\n\n def completed_cb(value: VT, key: KT) -> VT:\n pending_results[key] = value\n return value\n\n # Add a callback to fill out `pending_results` when that completes\n d = pending_value.deferred(key).addCallback(completed_cb, key)\n pending.append(d)\n continue\n\n # Not in either cache\n missing.append(key)\n\n # If we've got pending deferreds, squash them into a single one that\n # returns `pending_results`.\n pending_deferred = None\n if pending:\n pending_deferred = defer.gatherResults(\n pending, consumeErrors=True\n ).addCallback(lambda _: pending_results)\n\n return (cached, pending_deferred, missing)","def test_key_for_list_of_cacheable_objects(self):\n Meat.get_protein_sum([self.chicken, self.steak])\n expected_cache_key = 'tests.Meat.get_protein_sum;,Chicken:20,Steak:26;'\n self.assertExpectedKeyInCache(expected_cache_key)","def gets(self, keys, default=None, rec=False, txn=None):\n return (self.get(x, default, rec, txn) for k in keys)","def keys(self, *args, **kwargs):\n return self._list(*args, **kwargs)","def get_src_keys(self):\n timer = pytool.time.Timer()\n self.log.info(\"Querying source keys.\")\n self.src_keys = self.src.keys(self.prefix)\n self.log.info(f\"Retrieve source keys: {timer.elapsed}\")\n self.log.info(f\"Found {len(self.src_keys):,} source keys.\")","def iterkeys(self):","def iterkeys(self):","async def _multi_get(self, keys):\n with await self._connect() as redis:\n return await redis.mget(*keys)","def get_keys(self):\r\n return self._keys","def GetSubkeys(self):","async def get_keys(self, collection):\n raise NotImplementedError","def loadable_keys(self, fam=None):\n return []","def key_lookup_batch(self, batchiter):\n pass","def get_keys(self):\r\n\r\n #using database\r\n\r\n if self.using_database:\r\n aprint('GET KEYS')\r\n value_tuple = (notebookname,)\r\n db_cursor.execute(\"SELECT keyword\"\r\n +\" FROM keys_to_indexes\"\r\n +\" WHERE notebook=?;\",\r\n value_tuple)\r\n fetched = db_cursor.fetchall()\r\n if fetched:\r\n return {key[0] for key in fetched}\r\n\r\n return set()\r\n\r\n #using shelf\r\n\r\n return self.key_dict.keys()","def keys(self) -> List:\n pass","def account_keys(chain):\n return chain.backend.account_keys","def __getitem__(self,key):\n result = None\n # check if it's tin the cache first\n if key in self._cache:\n result = self._cache[key]\n else:\n # it's not in the cache so retrieve it\n result = self._get_from_tree(key)\n # remove None values\n result = [x for x in result if x is not None]\n self._cache[key] = result\n\n return result","def all():\n # results = [String.from_dict(redis.hgetall(key)) for key in redis.keys() if key != 'index']\n results = []\n for key in redis_store.keys(String.generate_key('*')):\n data = pickle.loads(redis_store.get(key))\n string = String(data['key']).deserialize(data)\n results.append(string)\n return results","def list_keys(self, bucket_name, prefix=None):\n url = self.endpoint + '/rest/v2/caches/' + self.cache_name + '?action=keys'\n res = self.infinispan_client.get(url, auth=self.basicAuth)\n data = res.content\n return data","def get_all_keys(self):\n r = []\n with self.lock:\n for key in self.keys():\n if self.get(key):\n r.append(key)\n\n return r","def get_keys(self) -> Dict[str, str]:\n return self.http.get(self.config.paths.keys)","def _get_cache_plus_key(self):\n\n dogpile_region = self.cache_regions[self._cache_region.region]\n if self._cache_region.cache_key:\n key = self._cache_region.cache_key\n else:\n key = _key_from_query(self)\n return dogpile_region, key","def __dask_keys__(self) -> list[Hashable]:\n raise NotImplementedError(\"Inheriting class must implement this method.\")","def __getitem__(self, key):\n if self._cache is None:\n self._cache = self.storer.read()\n\n try:\n return self._cache[key].values\n except KeyError:\n return self._get_constant_array(key)","def pullAll(*keys):","async def get_keys(self, collection):\n _LOGGER.debug(\"Getting %s from memory.\", collection)\n results = []\n for database in self.databases:\n results.append(await database.get_keys(collection))\n return results[0]","def pullSerializedAll(*keys):","def getData(self, local_cache):","def make_cache_keys(self, identifiers):\n\n raise NotImplementedError","async def keys(self) -> Iterable[str]:","def get_for_key(self, key) -> list:\n return [res[key] for res in self.list]","def get_multi(self, keys, missing=None, deferred=None,\n transaction=None, eventual=False, retry=None, timeout=None, read_time=None,\n model_type=None, expiry=86400):\n if not keys:\n return []\n get_multi_partial = partial(self.get_single, missing=missing, deferred=deferred, transaction=transaction,\n eventual=eventual, retry=retry, timeout=timeout, read_time=read_time,\n model_type=model_type, expiry=86400)\n with ThreadPoolExecutor(max_workers=min(len(keys), 10)) as executor:\n basemodels = []\n map_iterator = [[key] for key in keys]\n results = executor.map(get_multi_partial, map_iterator)\n for result in results:\n basemodels.append(result[0] if result else None)\n return basemodels","def get_all_keys(self, headers=None, **params):\r\n return self._get_all([('Contents', self.key_class),\r\n ('CommonPrefixes', Prefix)],\r\n '', headers, **params)","def Keys(self) -> NameObjectCollectionBase.KeysCollection:","def keys(self):\n raise NotImplementedError","def mget(self, keys, *args):\n args = list_or_args(keys, args)\n server_keys = {}\n ret_dict = {}\n for key in args:\n server_name = self.get_server_name(key)\n server_keys[server_name] = server_keys.get(server_name, [])\n server_keys[server_name].append(key)\n for server_name, sub_keys in iteritems(server_keys):\n values = self.connections[server_name].mget(sub_keys)\n ret_dict.update(dict(zip(sub_keys, values)))\n result = []\n for key in args:\n result.append(ret_dict.get(key, None))\n return result","def retrieve_keys(tags, common=True):\n r = StrictRedis.from_url('redis://10.0.0.10:6379')\n # if tags exist, filter them (later)\n # print(tags)\n if tags == []:\n return []\n else:\n print('FILTERING')\n if common:\n available_keys = set([])\n else:\n available_keys = [set([]) for tag in tags]\n # implement union of sets\n for count, tag in enumerate(tags):\n try:\n keys_list = r.get(tag.strip()).split(',')[1:]\n for key in keys_list:\n if common:\n available_keys.add(key)\n else:\n available_keys[count].add(key)\n except:\n print('Tag %s not found - check spelling' % tag)\n if not common:\n available_keys = set().intersection(*available_keys)\n return list(available_keys)","async def get() -> list:\n if _cache is None:\n await _update()\n return _cache","def keys(self, installer_context):\n return self.spec.keys(self.data, installer_context)","def get_keys(self):\n bucket = self.resource.Bucket(self.bucketname)\n return [key.key for key in bucket.objects.all()]","def get_keys2(self, key: str, epoch: int = None) -> Tuple[str, ...]:\n if epoch is None:\n epoch = self.get_epoch()\n d = self.stats[epoch][key]\n keys2 = tuple(k for k in d if k not in (\"time\", \"total_count\"))\n return keys2","def derivable_keys(self):\n res = []\n for cl in type(self).__mro__:\n if cl in self._derived_quantity_registry:\n res += list(self._derived_quantity_registry[cl].keys())\n return res","def get_all_keys(self, headers=None, **params):\r\n key = Key(self.name, self.contained_key)\r\n return SimpleResultSet([key])","def _get_cache_key_gen(\n param_names: Iterable[str],\n include_params: Iterable[bool],\n param_defaults: Mapping[str, Any],\n args: Sequence[Any],\n kwargs: Mapping[str, Any],\n) -> Iterable[Any]:\n # We loop through each arg name, looking up if its in the `kwargs`,\n # otherwise using the next argument in `args`. If there are no more\n # args then we try looking the arg name up in the defaults.\n pos = 0\n for nm, inc in zip(param_names, include_params):\n if nm in kwargs:\n if inc:\n yield kwargs[nm]\n elif pos < len(args):\n if inc:\n yield args[pos]\n pos += 1\n else:\n if inc:\n yield param_defaults[nm]","def getUncachedGameKeys(self):\n theKeys = HashSet()\n for game in theCacheDirectory.listFiles():\n theKeys.add(game.__name__.replace(\".zip\", \"\"))\n return theKeys","def _keys(self):\n for name in listdir(abspath(self._path)):\n key, ext = splitext(name)\n if ext == \".pkl\":\n yield key","def get_all(self, obj, keys_only=False):\n return obj.query().fetch(keys_only=keys_only)","def items(self, *args, **kwargs):\n return [ (key, self._get(key, *args, **kwargs),) for key in self.keys(*args, **kwargs) ]","def gen_keys():","def _cache_keys(self):\r\n fks = dict((f, getattr(self, f.attname)) for f in self._meta.fields\r\n if isinstance(f, models.ForeignKey))\r\n\r\n keys = [fk.rel.to._cache_key(val, self._state.db) for fk, val in fks.items()\r\n if val is not None and hasattr(fk.rel.to, '_cache_key')]\r\n return (self.cache_key,) + tuple(keys)","def keys(targets):","def AllKeys(self) -> _n_0_t_1[str]:","def get(self):\n if path.exists(self.cachefile):\n self.invalidion()\n full_cache = self._get_all()\n return full_cache\n else:\n return []","def list_objects(self, bucket_name, prefix=None):\n url = self.endpoint + '/rest/v2/caches/' + self.cache_name + '?action=keys'\n res = self.infinispan_client.get(url, auth=self.basicAuth)\n data = res.content\n return data","def get_many(self, keys: Iterable, version: Optional[int] = None) -> Dict[str, Any]:\n d = {}\n for k in keys:\n val = self.get(k, version=version)\n if val is not None:\n d[k] = val\n return d","def getall(self, key):\n return self.values.get(key, [])","def get_cache(self, key):\n return self.r.get(key)","def load_cache():\n return {}","def combine_cache_keys(cache_keys):\r\n if len(cache_keys) == 1:\r\n return cache_keys[0]\r\n else:\r\n combined_id = Target.maybe_readable_combine_ids(cache_key.id for cache_key in cache_keys)\r\n combined_hash = hash_all(sorted(cache_key.hash for cache_key in cache_keys))\r\n combined_num_sources = sum(cache_key.num_sources for cache_key in cache_keys)\r\n combined_sources = \\\r\n sorted(list(itertools.chain(*[cache_key.sources for cache_key in cache_keys])))\r\n return CacheKey(combined_id, combined_hash, combined_num_sources, combined_sources)","def get_by_list_of_keys(dictionary: Dict, key_path: List[Any]) -> Dict:\n if len(key_path) == 1:\n return dictionary[key_path[0]]\n else:\n return get_by_list_of_keys(dictionary[key_path[0]], key_path[1:])","def multiget_direct(self, keys, *args, **kwargs):\n return pycassa.ColumnFamily.multiget(self, keys, *args, **kwargs)","def _GetEntityKeysByPrefix(model, prefix):\n return model.query().filter(\n model.key >= ndb.Key(model, prefix),\n model.key < ndb.Key(model, prefix + u'ufffd')).fetch(keys_only=True)","def keys(self, installer_context):\n keys = set()\n for source in self.sources:\n keys.update(set(source.keys(installer_context)))\n return list(keys)","def get_keys(self, ckey=None):\n if ckey:\n keys = self._get_keys(ckey)\n else:\n keys = self.keys()\n for key in self.keys():\n keys += [k for k in self._get_keys(key)]\n return list(set(keys))","def Keys(self) -> _n_1_t_4:","def get_all_keys(self):\r\n all_keys = []\r\n for i in range(len(self.hash_table)):\r\n if self.hash_table[i] is not None:\r\n all_keys.append(self.hash_table[i].key)\r\n return all_keys","def __getitem__(self, key):\n if isinstance(key, int):\n if key < 0:\n raise IndexError('Cannot index less than 0')\n offset = key % BLOCK_SIZE\n index = (key/BLOCK_SIZE) % CACHE_ENTRIES\n tag = self.start + ((((key/BLOCK_SIZE)*BLOCK_SIZE)/SAMPLE_RATE)*qdf.SECOND)\n if self.cache[index][CACHE_INDEX_TAG] == None:\n #cache entry is empty\n yield self._query_data(index, tag)\n elif self.cache[index][CACHE_INDEX_TAG] != tag:\n #cache miss\n yield self._query_data(index, tag)\n datapoint = self.cache[index][CACHE_INDEX_DATA][offset]\n if datapoint == None:\n defer.returnValue(datapoint)\n if datapoint.time > self.end:\n raise IndexError('Requested date past end-date:\\n'+\n 'End-Date: '+str(self.end)+'\\n'+\n 'Requested-Date: '+str(self.cache[index][offset].time))\n defer.returnValue(datapoint)\n\n elif isinstance(key, slice):\n #not implemented yet\n raise TypeError('list indices must be integers, not '+type(key))\n else: #slice error\n raise TypeError('list indices must be integers, not '+type(key))","def _map___iter__(self):\n return self.iterkeys()","def get_chunks_result(self, data_keys: List[str], fetch_only: bool = False) -> List:","def keys(self):\n raise NotImplementedError('keys() should have been replaced by a metaclass')","def mget(self, keys: List[K]) -> List[Optional[V]]:\n raise NotImplementedError('mget must be reimplemented in concrete implementation')","def get_many(self, *keys):\n key_x_value = self.get_dict(*keys)\n return [key_x_value[key] for key in keys]","def getitems(self):\n return {k:self.get(k) for k in self.keys}","def _memcache_get(*args, **kwargs):\n return ndb.get_context().memcache_get(*args, **kwargs)","def return_keys(tsd):\n return list(tsd.keys())","def _getbundlelistkeysparts(\n bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs\n):\n listkeys = kwargs.get('listkeys', ())\n for namespace in listkeys:\n part = bundler.newpart(b'listkeys')\n part.addparam(b'namespace', namespace)\n keys = repo.listkeys(namespace).items()\n part.data = pushkey.encodekeys(keys)","def fetchAll(self, *args, **kwargs):\n return KorAPClient.fetchAll(self, *args, **kwargs)","def get(key):\n return Cache.cache_connector.get(key)","def all(self):\n if not self._cache:\n self.load()\n\n return self._cache","def iterkeyrefs(self):\r\n return self.data.iterkeys()"],"string":"[\n \"async def _multi_get(self, keys, encoding=\\\"utf-8\\\"):\\n return [SimpleMemoryBackend._cache.get(key) for key in keys]\",\n \"def keys_fetch(self):\\n with self.env.begin(write=False) as txn:\\n cursor = txn.cursor()\\n tot = txn.stat()['entries']\\n i = 0\\n\\n path = self.db_path\\n base_name = self.base_path\\n cache_file_path = os.path.join(path, '_cache_' + base_name + '.pkl')\\n print('cache_file_path = ', cache_file_path) # DEBUG\\n\\n if os.path.isfile(cache_file_path):\\n self.keys = pickle.load(open(cache_file_path, 'rb'))\\n self._num_examples = tot\\n else:\\n keys = []\\n for key, _ in cursor:\\n i += 1\\n if i % 1000 == 0 or i == tot:\\n print('Fetching {:>8d} /{:>8d} keys'.format(i, tot),\\n end='\\\\r')\\n keys.append(key)\\n print('\\\\nDone.')\\n self._num_examples = tot\\n self.keys = np.asarray(keys)\\n pickle.dump(self.keys, open(cache_file_path, 'wb'))\",\n \"def keysAll():\",\n \"def fetch_objects(cache_key_f, get_database_f, item_keys):\\r\\n item_key_to_item = get_many_by_key(cache_key_f, item_keys)\\r\\n \\r\\n for item_key in item_keys:\\r\\n if item_key not in item_key_to_item:\\r\\n # failed to get the item from the cache\\r\\n try:\\r\\n # have to get each item individually to cache the query\\r\\n item = get_database_f(item_key)\\r\\n item_key_to_item[item_key] = item\\r\\n except ObjectDoesNotExist:\\r\\n pass\\r\\n \\r\\n return item_key_to_item\",\n \"def findall(self, key_list):\\n for i in range(3):\\n try:\\n return self.redis_handler.mget(key_list) \\n except:\\n continue\",\n \"def all_keys(self):\\n return self.derivable_keys() + self.loadable_keys()\",\n \"def get(self, key: Any, **kwargs) -> Iterable:\\n return self.store.get(key, **kwargs)\",\n \"def get_many_by_key(cache_key_f, item_keys, version=None):\\r\\n cache_key_to_item_key = {}\\r\\n for item_key in item_keys:\\r\\n cache_key = cache.make_key(cache_key_f(item_key), version=version)\\r\\n cache_key_to_item_key[cache_key] = item_key\\r\\n\\r\\n # request from cache\\r\\n from_cache = cache.get_many(cache_key_to_item_key.keys())\\r\\n\\r\\n results = {}\\r\\n for cache_key, value in from_cache.iteritems():\\r\\n item_key = cache_key_to_item_key[cache_key]\\r\\n results[item_key] = value\\r\\n return results\",\n \"def keys(self, key=None, lo=None, hi=None, reverse=None, max=None,\\n include=False, txn=None, rec=None):\\n return itertools.imap(ITEMGETTER_0,\\n self.items(key, lo, hi, reverse, max, include, txn, rec))\",\n \"def _get_keys(self, listOfKeys):\\n return self._keys\",\n \"def get_many(self, keys, default=None):\\n raise NotImplementedError()\",\n \"def keys(self, args=None, lo=None, hi=None, reverse=None, max=None,\\n include=False, txn=None):\\n return itertools.imap(ITEMGETTER_1,\\n self.pairs(args, lo, hi, reverse, max, include, txn))\",\n \"async def get_all(self, key: datastore.Key) -> RV:\\n\\t\\treturn await (await self.get(key)).collect() # type: ignore[return-value]\",\n \"def ikeys(self, prefix=''):\",\n \"def multiget(self, keys):\\n return self.sp.multiget(keys)\",\n \"def keys():\",\n \"def cache_key(self):\",\n \"def get_keys(self):\\r\\n\\t\\tlogger.debug(\\\"Getting the keys\\\")\\r\\n\\t\\t\\r\\n\\t\\treturn db.get_items('keys')\",\n \"def get_key_set():\\n keys = [0] * n_families\\n for i in range(n_families):\\n keys[i] = get_key(i)\\n\\n return keys\",\n \"def keys(self, **kwargs) -> Iterable:\\n return self.store.keys(**kwargs)\",\n \"def get_bulk(\\n self,\\n keys: Collection[KT],\\n callback: Optional[Callable[[], None]] = None,\\n ) -> Tuple[Dict[KT, VT], Optional[\\\"defer.Deferred[Dict[KT, VT]]\\\"], Collection[KT]]:\\n\\n # The cached results\\n cached = {}\\n\\n # List of pending deferreds\\n pending = []\\n\\n # Dict that gets filled out when the pending deferreds complete\\n pending_results = {}\\n\\n # List of keys that aren't in either cache\\n missing = []\\n\\n callbacks = (callback,) if callback else ()\\n\\n for key in keys:\\n # Check if its in the main cache.\\n immediate_value = self.cache.get(\\n key,\\n _Sentinel.sentinel,\\n callbacks=callbacks,\\n )\\n if immediate_value is not _Sentinel.sentinel:\\n cached[key] = immediate_value\\n continue\\n\\n # Check if its in the pending cache\\n pending_value = self._pending_deferred_cache.get(key, _Sentinel.sentinel)\\n if pending_value is not _Sentinel.sentinel:\\n pending_value.add_invalidation_callback(key, callback)\\n\\n def completed_cb(value: VT, key: KT) -> VT:\\n pending_results[key] = value\\n return value\\n\\n # Add a callback to fill out `pending_results` when that completes\\n d = pending_value.deferred(key).addCallback(completed_cb, key)\\n pending.append(d)\\n continue\\n\\n # Not in either cache\\n missing.append(key)\\n\\n # If we've got pending deferreds, squash them into a single one that\\n # returns `pending_results`.\\n pending_deferred = None\\n if pending:\\n pending_deferred = defer.gatherResults(\\n pending, consumeErrors=True\\n ).addCallback(lambda _: pending_results)\\n\\n return (cached, pending_deferred, missing)\",\n \"def test_key_for_list_of_cacheable_objects(self):\\n Meat.get_protein_sum([self.chicken, self.steak])\\n expected_cache_key = 'tests.Meat.get_protein_sum;,Chicken:20,Steak:26;'\\n self.assertExpectedKeyInCache(expected_cache_key)\",\n \"def gets(self, keys, default=None, rec=False, txn=None):\\n return (self.get(x, default, rec, txn) for k in keys)\",\n \"def keys(self, *args, **kwargs):\\n return self._list(*args, **kwargs)\",\n \"def get_src_keys(self):\\n timer = pytool.time.Timer()\\n self.log.info(\\\"Querying source keys.\\\")\\n self.src_keys = self.src.keys(self.prefix)\\n self.log.info(f\\\"Retrieve source keys: {timer.elapsed}\\\")\\n self.log.info(f\\\"Found {len(self.src_keys):,} source keys.\\\")\",\n \"def iterkeys(self):\",\n \"def iterkeys(self):\",\n \"async def _multi_get(self, keys):\\n with await self._connect() as redis:\\n return await redis.mget(*keys)\",\n \"def get_keys(self):\\r\\n return self._keys\",\n \"def GetSubkeys(self):\",\n \"async def get_keys(self, collection):\\n raise NotImplementedError\",\n \"def loadable_keys(self, fam=None):\\n return []\",\n \"def key_lookup_batch(self, batchiter):\\n pass\",\n \"def get_keys(self):\\r\\n\\r\\n #using database\\r\\n\\r\\n if self.using_database:\\r\\n aprint('GET KEYS')\\r\\n value_tuple = (notebookname,)\\r\\n db_cursor.execute(\\\"SELECT keyword\\\"\\r\\n +\\\" FROM keys_to_indexes\\\"\\r\\n +\\\" WHERE notebook=?;\\\",\\r\\n value_tuple)\\r\\n fetched = db_cursor.fetchall()\\r\\n if fetched:\\r\\n return {key[0] for key in fetched}\\r\\n\\r\\n return set()\\r\\n\\r\\n #using shelf\\r\\n\\r\\n return self.key_dict.keys()\",\n \"def keys(self) -> List:\\n pass\",\n \"def account_keys(chain):\\n return chain.backend.account_keys\",\n \"def __getitem__(self,key):\\n result = None\\n # check if it's tin the cache first\\n if key in self._cache:\\n result = self._cache[key]\\n else:\\n # it's not in the cache so retrieve it\\n result = self._get_from_tree(key)\\n # remove None values\\n result = [x for x in result if x is not None]\\n self._cache[key] = result\\n\\n return result\",\n \"def all():\\n # results = [String.from_dict(redis.hgetall(key)) for key in redis.keys() if key != 'index']\\n results = []\\n for key in redis_store.keys(String.generate_key('*')):\\n data = pickle.loads(redis_store.get(key))\\n string = String(data['key']).deserialize(data)\\n results.append(string)\\n return results\",\n \"def list_keys(self, bucket_name, prefix=None):\\n url = self.endpoint + '/rest/v2/caches/' + self.cache_name + '?action=keys'\\n res = self.infinispan_client.get(url, auth=self.basicAuth)\\n data = res.content\\n return data\",\n \"def get_all_keys(self):\\n r = []\\n with self.lock:\\n for key in self.keys():\\n if self.get(key):\\n r.append(key)\\n\\n return r\",\n \"def get_keys(self) -> Dict[str, str]:\\n return self.http.get(self.config.paths.keys)\",\n \"def _get_cache_plus_key(self):\\n\\n dogpile_region = self.cache_regions[self._cache_region.region]\\n if self._cache_region.cache_key:\\n key = self._cache_region.cache_key\\n else:\\n key = _key_from_query(self)\\n return dogpile_region, key\",\n \"def __dask_keys__(self) -> list[Hashable]:\\n raise NotImplementedError(\\\"Inheriting class must implement this method.\\\")\",\n \"def __getitem__(self, key):\\n if self._cache is None:\\n self._cache = self.storer.read()\\n\\n try:\\n return self._cache[key].values\\n except KeyError:\\n return self._get_constant_array(key)\",\n \"def pullAll(*keys):\",\n \"async def get_keys(self, collection):\\n _LOGGER.debug(\\\"Getting %s from memory.\\\", collection)\\n results = []\\n for database in self.databases:\\n results.append(await database.get_keys(collection))\\n return results[0]\",\n \"def pullSerializedAll(*keys):\",\n \"def getData(self, local_cache):\",\n \"def make_cache_keys(self, identifiers):\\n\\n raise NotImplementedError\",\n \"async def keys(self) -> Iterable[str]:\",\n \"def get_for_key(self, key) -> list:\\n return [res[key] for res in self.list]\",\n \"def get_multi(self, keys, missing=None, deferred=None,\\n transaction=None, eventual=False, retry=None, timeout=None, read_time=None,\\n model_type=None, expiry=86400):\\n if not keys:\\n return []\\n get_multi_partial = partial(self.get_single, missing=missing, deferred=deferred, transaction=transaction,\\n eventual=eventual, retry=retry, timeout=timeout, read_time=read_time,\\n model_type=model_type, expiry=86400)\\n with ThreadPoolExecutor(max_workers=min(len(keys), 10)) as executor:\\n basemodels = []\\n map_iterator = [[key] for key in keys]\\n results = executor.map(get_multi_partial, map_iterator)\\n for result in results:\\n basemodels.append(result[0] if result else None)\\n return basemodels\",\n \"def get_all_keys(self, headers=None, **params):\\r\\n return self._get_all([('Contents', self.key_class),\\r\\n ('CommonPrefixes', Prefix)],\\r\\n '', headers, **params)\",\n \"def Keys(self) -> NameObjectCollectionBase.KeysCollection:\",\n \"def keys(self):\\n raise NotImplementedError\",\n \"def mget(self, keys, *args):\\n args = list_or_args(keys, args)\\n server_keys = {}\\n ret_dict = {}\\n for key in args:\\n server_name = self.get_server_name(key)\\n server_keys[server_name] = server_keys.get(server_name, [])\\n server_keys[server_name].append(key)\\n for server_name, sub_keys in iteritems(server_keys):\\n values = self.connections[server_name].mget(sub_keys)\\n ret_dict.update(dict(zip(sub_keys, values)))\\n result = []\\n for key in args:\\n result.append(ret_dict.get(key, None))\\n return result\",\n \"def retrieve_keys(tags, common=True):\\n r = StrictRedis.from_url('redis://10.0.0.10:6379')\\n # if tags exist, filter them (later)\\n # print(tags)\\n if tags == []:\\n return []\\n else:\\n print('FILTERING')\\n if common:\\n available_keys = set([])\\n else:\\n available_keys = [set([]) for tag in tags]\\n # implement union of sets\\n for count, tag in enumerate(tags):\\n try:\\n keys_list = r.get(tag.strip()).split(',')[1:]\\n for key in keys_list:\\n if common:\\n available_keys.add(key)\\n else:\\n available_keys[count].add(key)\\n except:\\n print('Tag %s not found - check spelling' % tag)\\n if not common:\\n available_keys = set().intersection(*available_keys)\\n return list(available_keys)\",\n \"async def get() -> list:\\n if _cache is None:\\n await _update()\\n return _cache\",\n \"def keys(self, installer_context):\\n return self.spec.keys(self.data, installer_context)\",\n \"def get_keys(self):\\n bucket = self.resource.Bucket(self.bucketname)\\n return [key.key for key in bucket.objects.all()]\",\n \"def get_keys2(self, key: str, epoch: int = None) -> Tuple[str, ...]:\\n if epoch is None:\\n epoch = self.get_epoch()\\n d = self.stats[epoch][key]\\n keys2 = tuple(k for k in d if k not in (\\\"time\\\", \\\"total_count\\\"))\\n return keys2\",\n \"def derivable_keys(self):\\n res = []\\n for cl in type(self).__mro__:\\n if cl in self._derived_quantity_registry:\\n res += list(self._derived_quantity_registry[cl].keys())\\n return res\",\n \"def get_all_keys(self, headers=None, **params):\\r\\n key = Key(self.name, self.contained_key)\\r\\n return SimpleResultSet([key])\",\n \"def _get_cache_key_gen(\\n param_names: Iterable[str],\\n include_params: Iterable[bool],\\n param_defaults: Mapping[str, Any],\\n args: Sequence[Any],\\n kwargs: Mapping[str, Any],\\n) -> Iterable[Any]:\\n # We loop through each arg name, looking up if its in the `kwargs`,\\n # otherwise using the next argument in `args`. If there are no more\\n # args then we try looking the arg name up in the defaults.\\n pos = 0\\n for nm, inc in zip(param_names, include_params):\\n if nm in kwargs:\\n if inc:\\n yield kwargs[nm]\\n elif pos < len(args):\\n if inc:\\n yield args[pos]\\n pos += 1\\n else:\\n if inc:\\n yield param_defaults[nm]\",\n \"def getUncachedGameKeys(self):\\n theKeys = HashSet()\\n for game in theCacheDirectory.listFiles():\\n theKeys.add(game.__name__.replace(\\\".zip\\\", \\\"\\\"))\\n return theKeys\",\n \"def _keys(self):\\n for name in listdir(abspath(self._path)):\\n key, ext = splitext(name)\\n if ext == \\\".pkl\\\":\\n yield key\",\n \"def get_all(self, obj, keys_only=False):\\n return obj.query().fetch(keys_only=keys_only)\",\n \"def items(self, *args, **kwargs):\\n return [ (key, self._get(key, *args, **kwargs),) for key in self.keys(*args, **kwargs) ]\",\n \"def gen_keys():\",\n \"def _cache_keys(self):\\r\\n fks = dict((f, getattr(self, f.attname)) for f in self._meta.fields\\r\\n if isinstance(f, models.ForeignKey))\\r\\n\\r\\n keys = [fk.rel.to._cache_key(val, self._state.db) for fk, val in fks.items()\\r\\n if val is not None and hasattr(fk.rel.to, '_cache_key')]\\r\\n return (self.cache_key,) + tuple(keys)\",\n \"def keys(targets):\",\n \"def AllKeys(self) -> _n_0_t_1[str]:\",\n \"def get(self):\\n if path.exists(self.cachefile):\\n self.invalidion()\\n full_cache = self._get_all()\\n return full_cache\\n else:\\n return []\",\n \"def list_objects(self, bucket_name, prefix=None):\\n url = self.endpoint + '/rest/v2/caches/' + self.cache_name + '?action=keys'\\n res = self.infinispan_client.get(url, auth=self.basicAuth)\\n data = res.content\\n return data\",\n \"def get_many(self, keys: Iterable, version: Optional[int] = None) -> Dict[str, Any]:\\n d = {}\\n for k in keys:\\n val = self.get(k, version=version)\\n if val is not None:\\n d[k] = val\\n return d\",\n \"def getall(self, key):\\n return self.values.get(key, [])\",\n \"def get_cache(self, key):\\n return self.r.get(key)\",\n \"def load_cache():\\n return {}\",\n \"def combine_cache_keys(cache_keys):\\r\\n if len(cache_keys) == 1:\\r\\n return cache_keys[0]\\r\\n else:\\r\\n combined_id = Target.maybe_readable_combine_ids(cache_key.id for cache_key in cache_keys)\\r\\n combined_hash = hash_all(sorted(cache_key.hash for cache_key in cache_keys))\\r\\n combined_num_sources = sum(cache_key.num_sources for cache_key in cache_keys)\\r\\n combined_sources = \\\\\\r\\n sorted(list(itertools.chain(*[cache_key.sources for cache_key in cache_keys])))\\r\\n return CacheKey(combined_id, combined_hash, combined_num_sources, combined_sources)\",\n \"def get_by_list_of_keys(dictionary: Dict, key_path: List[Any]) -> Dict:\\n if len(key_path) == 1:\\n return dictionary[key_path[0]]\\n else:\\n return get_by_list_of_keys(dictionary[key_path[0]], key_path[1:])\",\n \"def multiget_direct(self, keys, *args, **kwargs):\\n return pycassa.ColumnFamily.multiget(self, keys, *args, **kwargs)\",\n \"def _GetEntityKeysByPrefix(model, prefix):\\n return model.query().filter(\\n model.key >= ndb.Key(model, prefix),\\n model.key < ndb.Key(model, prefix + u'ufffd')).fetch(keys_only=True)\",\n \"def keys(self, installer_context):\\n keys = set()\\n for source in self.sources:\\n keys.update(set(source.keys(installer_context)))\\n return list(keys)\",\n \"def get_keys(self, ckey=None):\\n if ckey:\\n keys = self._get_keys(ckey)\\n else:\\n keys = self.keys()\\n for key in self.keys():\\n keys += [k for k in self._get_keys(key)]\\n return list(set(keys))\",\n \"def Keys(self) -> _n_1_t_4:\",\n \"def get_all_keys(self):\\r\\n all_keys = []\\r\\n for i in range(len(self.hash_table)):\\r\\n if self.hash_table[i] is not None:\\r\\n all_keys.append(self.hash_table[i].key)\\r\\n return all_keys\",\n \"def __getitem__(self, key):\\n if isinstance(key, int):\\n if key < 0:\\n raise IndexError('Cannot index less than 0')\\n offset = key % BLOCK_SIZE\\n index = (key/BLOCK_SIZE) % CACHE_ENTRIES\\n tag = self.start + ((((key/BLOCK_SIZE)*BLOCK_SIZE)/SAMPLE_RATE)*qdf.SECOND)\\n if self.cache[index][CACHE_INDEX_TAG] == None:\\n #cache entry is empty\\n yield self._query_data(index, tag)\\n elif self.cache[index][CACHE_INDEX_TAG] != tag:\\n #cache miss\\n yield self._query_data(index, tag)\\n datapoint = self.cache[index][CACHE_INDEX_DATA][offset]\\n if datapoint == None:\\n defer.returnValue(datapoint)\\n if datapoint.time > self.end:\\n raise IndexError('Requested date past end-date:\\\\n'+\\n 'End-Date: '+str(self.end)+'\\\\n'+\\n 'Requested-Date: '+str(self.cache[index][offset].time))\\n defer.returnValue(datapoint)\\n\\n elif isinstance(key, slice):\\n #not implemented yet\\n raise TypeError('list indices must be integers, not '+type(key))\\n else: #slice error\\n raise TypeError('list indices must be integers, not '+type(key))\",\n \"def _map___iter__(self):\\n return self.iterkeys()\",\n \"def get_chunks_result(self, data_keys: List[str], fetch_only: bool = False) -> List:\",\n \"def keys(self):\\n raise NotImplementedError('keys() should have been replaced by a metaclass')\",\n \"def mget(self, keys: List[K]) -> List[Optional[V]]:\\n raise NotImplementedError('mget must be reimplemented in concrete implementation')\",\n \"def get_many(self, *keys):\\n key_x_value = self.get_dict(*keys)\\n return [key_x_value[key] for key in keys]\",\n \"def getitems(self):\\n return {k:self.get(k) for k in self.keys}\",\n \"def _memcache_get(*args, **kwargs):\\n return ndb.get_context().memcache_get(*args, **kwargs)\",\n \"def return_keys(tsd):\\n return list(tsd.keys())\",\n \"def _getbundlelistkeysparts(\\n bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs\\n):\\n listkeys = kwargs.get('listkeys', ())\\n for namespace in listkeys:\\n part = bundler.newpart(b'listkeys')\\n part.addparam(b'namespace', namespace)\\n keys = repo.listkeys(namespace).items()\\n part.data = pushkey.encodekeys(keys)\",\n \"def fetchAll(self, *args, **kwargs):\\n return KorAPClient.fetchAll(self, *args, **kwargs)\",\n \"def get(key):\\n return Cache.cache_connector.get(key)\",\n \"def all(self):\\n if not self._cache:\\n self.load()\\n\\n return self._cache\",\n \"def iterkeyrefs(self):\\r\\n return self.data.iterkeys()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6834069","0.6382025","0.6335966","0.62565744","0.624546","0.6219669","0.6212312","0.61953014","0.61886495","0.61742663","0.6109253","0.60742164","0.6064275","0.60528266","0.6002826","0.5956592","0.59504443","0.59299576","0.58935183","0.58931494","0.58847415","0.58761984","0.5875029","0.5866343","0.5851507","0.5849811","0.5849811","0.5841344","0.58394384","0.5812538","0.58046854","0.58013016","0.5758985","0.57562363","0.57561296","0.5755218","0.5755202","0.5736162","0.57272404","0.5704264","0.5679478","0.5664175","0.5657747","0.56460977","0.56319314","0.5629793","0.5628524","0.56271887","0.5617227","0.56051964","0.55912405","0.557543","0.55716515","0.5569226","0.55553365","0.5541243","0.55264163","0.55259955","0.55248666","0.55168235","0.55136937","0.55113494","0.5511119","0.5510994","0.5507398","0.5490778","0.5490329","0.54832375","0.54748917","0.5473455","0.5465362","0.5461676","0.5459977","0.5458","0.5446956","0.5441709","0.5440727","0.5434516","0.54133683","0.5406832","0.540482","0.5403919","0.5402485","0.54011416","0.53980887","0.53948784","0.53909576","0.5385733","0.53763974","0.5370982","0.53670704","0.53577787","0.5346862","0.5343271","0.53432006","0.5342684","0.5336156","0.5335977","0.5331304","0.53296065"],"string":"[\n \"0.6834069\",\n \"0.6382025\",\n \"0.6335966\",\n \"0.62565744\",\n \"0.624546\",\n \"0.6219669\",\n \"0.6212312\",\n \"0.61953014\",\n \"0.61886495\",\n \"0.61742663\",\n \"0.6109253\",\n \"0.60742164\",\n \"0.6064275\",\n \"0.60528266\",\n \"0.6002826\",\n \"0.5956592\",\n \"0.59504443\",\n \"0.59299576\",\n \"0.58935183\",\n \"0.58931494\",\n \"0.58847415\",\n \"0.58761984\",\n \"0.5875029\",\n \"0.5866343\",\n \"0.5851507\",\n \"0.5849811\",\n \"0.5849811\",\n \"0.5841344\",\n \"0.58394384\",\n \"0.5812538\",\n \"0.58046854\",\n \"0.58013016\",\n \"0.5758985\",\n \"0.57562363\",\n \"0.57561296\",\n \"0.5755218\",\n \"0.5755202\",\n \"0.5736162\",\n \"0.57272404\",\n \"0.5704264\",\n \"0.5679478\",\n \"0.5664175\",\n \"0.5657747\",\n \"0.56460977\",\n \"0.56319314\",\n \"0.5629793\",\n \"0.5628524\",\n \"0.56271887\",\n \"0.5617227\",\n \"0.56051964\",\n \"0.55912405\",\n \"0.557543\",\n \"0.55716515\",\n \"0.5569226\",\n \"0.55553365\",\n \"0.5541243\",\n \"0.55264163\",\n \"0.55259955\",\n \"0.55248666\",\n \"0.55168235\",\n \"0.55136937\",\n \"0.55113494\",\n \"0.5511119\",\n \"0.5510994\",\n \"0.5507398\",\n \"0.5490778\",\n \"0.5490329\",\n \"0.54832375\",\n \"0.54748917\",\n \"0.5473455\",\n \"0.5465362\",\n \"0.5461676\",\n \"0.5459977\",\n \"0.5458\",\n \"0.5446956\",\n \"0.5441709\",\n \"0.5440727\",\n \"0.5434516\",\n \"0.54133683\",\n \"0.5406832\",\n \"0.540482\",\n \"0.5403919\",\n \"0.5402485\",\n \"0.54011416\",\n \"0.53980887\",\n \"0.53948784\",\n \"0.53909576\",\n \"0.5385733\",\n \"0.53763974\",\n \"0.5370982\",\n \"0.53670704\",\n \"0.53577787\",\n \"0.5346862\",\n \"0.5343271\",\n \"0.53432006\",\n \"0.5342684\",\n \"0.5336156\",\n \"0.5335977\",\n \"0.5331304\",\n \"0.53296065\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6371455"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":14882,"cells":{"query":{"kind":"string","value":"Get value for the key"},"document":{"kind":"string","value":"def get(self, key: K)-> Optional[V]:\n return self._func(key)"},"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_value(self, key):\n pass","def get_value(self, key):\n return self[key]","def get_value(self, key):\n return self.data.get(key)","def get_value(self, key):\n return self[key]['value']","def get( self, key ):\n if key not in self._values:\n raise ValueError( 'Invalid argument key \"{}\".'.format( key ) )\n return self._values[ key ]","def get(self, key):\n return self[key]","def get(self, key):\n\t\treturn self.__get(key, key[1:])","def value(self, key):\n item = self.default(key)\n return self.__getSafeValue(key, item)","def get_value(self, key):\n try:\n return self.map[key]\n except KeyError:\n raise KeyError('key is not in map')","def get(self, key):\n h = key%self.m\n a = self.a\n if a[h]:\n return a[h].val\n else:\n return -1","def __getitem__(self, key):\n return self.keyvaluepair_set.get(key=key).value","def get_value(self, key: str) -> Optional[str]:\n raise NotImplementedError","def get_value(self, key: str) -> Any:\r\n if key is None:\r\n return self.data\r\n try:\r\n return self.data[key]\r\n except KeyError:\r\n return None","def get(self, key):","def get(self, key):","def get(self, key):\n return self.arr[key]","def get_value(key):\n\n oErr = ErrHandle()\n infoval = None\n try:\n obj = TsgInfo.objects.filter(infokey__iexact=key).first()\n if obj != None:\n infoval = obj.infoval\n except:\n msg = oErr.get_error_message()\n oErr.DoError(\"TsgInfo/get_value\")\n return infoval","def GetValue(self, key):\n return self._metadata_dict[key]","def get(self, key):\n try:\n return(self._data[key])\n except:\n log.error(\"Can't get data '%s'\" % key)\n return","async def get(self, key):\n return self.dict.get(key, None)","def get(self, key):\n pass","def get(self, key):\n return self.sp.get(key)","def get_value(self, conn, key):\n if self.exists(conn, key):\n return conn.get(key)\n else:\n raise Exception, \"No key (%s) exists\" %key","def __getitem__(self, key):\n return self.params[key].value","def get(self, key):\n if type(key) != str:\n raise TypeError(\"This is not the string you're looking for!\")\n number = self._hash(key)\n stored_key = number if self.function == 'fnv' else key\n try:\n return self.bucket_list[number % self.bucket_number].search(stored_key).stored_value\n except AttributeError:\n return None","def getKeyValue(self,\n key,\n no = 0):\n keyword = key + \"___\" + str(no + 1)\n return self.__keyObjs[keyword].getValue()","def get(self, key: K) -> Optional[V]:\n return self.mget([key])[0]","def get(self, key):\n # TODO: Check if the given key exists and return its associated value\n hash_key = self._bucket_index(key) # Gets the index of the key\n\n if self.buckets[hash_key].is_empty() is False: # If the hask_key exists\n for key_value_pair in self.buckets[hash_key]: # Iteratre through the value pair\n if key_value_pair[0] is key: # If the key matches\n return key_value_pair[1] # Return the value\n raise KeyError(\"Key doesn't exist\") # If key doesn't exist, return None","def get_value(self, key):\r\n if self.hash_table[self.horner_hash(key)] is not None:\r\n if self.hash_table[self.horner_hash(key)].key == key:\r\n return self.hash_table[self.horner_hash(key)].value\r\n else:\r\n return None","def __getitem__(self, key):\n\n return self.values[key]","def __getitem__(self, key):\n return self._get(key)","def get(self, key):\r\n if not isinstance(key, str):\r\n raise TypeError(\"Key must be a string\")\r\n\r\n node = self._find_node(key)\r\n if node is None:\r\n return None\r\n else:\r\n return node.value[1]","def get(key):\n return current().values[key]","def __getitem__(self, key):\n ndx = self._findPosition(key)\n assert ndx is not None, 'Invalid map key'\n return self._entryList[ndx].value","def __getitem__(self, key):\n return self.get(key)","def __getitem__(self, key):\n return self.get(key)","def __getitem__(self, key):\n return self.get(key)","def get(self, key):\n raise NotImplementedError","def get(self, key):\n return self.container[key]","def get_value(self, key):\n if key not in self._config:\n raise ValueError(\"%s not in self.config\"%key)\n return self._config[key][\"value\"]","def get(self, key):\n hash_key = key % self.key_space\n return self.hash_table[hash_key].get(key)","def get(self, key):\n return self.execute_command(self.GET_CMD, key)","def get_value(dct, key):\n return dct.get(key)","def __getitem__(self, key):\n return self.parameters[key].value","def __getitem__(self, key):\n return self.data.get(key, '')","def get(self, key, default=None):\n key = self._validate_key(key)\n sql = u\"\"\"\n SELECT `value` FROM `{table}` WHERE key = ?\n \"\"\".format(table=self.name)\n\n r = self.conn.execute(sql, (key,)).fetchone()\n\n if r:\n return self.convert_out(r['value'])\n\n return default","def get(self, key):\n node = self._get_node(key)\n\n if node:\n return node.data","def get(self, key):\n return getattr(self, key)","def get_value(self, key: Union[str, ConfigurationVariable]) -> Any:\n if not key:\n raise KeyError(key)\n key_str = key.name if isinstance(key, ConfigurationVariable) else key\n return self._fetch_value(key_str)","def _get(self, key: str):\n pass","def get(self, key):\n # Find bucket where given key belongs\n # Check if key-value entry exists in bucket\n # If found, return value associated with given key\n # Otherwise, raise error to tell user get failed\n # Hint: raise KeyError('Key not found: {}'.format(key))\n key_bucket = self._bucket_index(key)\n\n for key_value_tuple in self.buckets[key_bucket].items():\n if key_value_tuple[0] is key:\n return key_value_tuple[1]\n\n raise KeyError('Key not found: {}'.format(key))","def get(self, key: str) -> str:\n hashkey = self._gethash(key)\n if type(self.HashMap[hashkey]) is list:\n if len(self.HashMap[hashkey]) > 2:\n \"\"\"\n Return correct Key and value from the\n location which has a hashclash\n \"\"\"\n idx = self._find_if_hashclash(key, hashkey, \"v\")\n if idx is not None:\n return self.HashMap[hashkey][idx]\n elif self.HashMap[hashkey][0] == key:\n # Check that the data matches the key and return it if it does\n return self.HashMap[hashkey][1]\n return \"\"","def get(self, key):\n return self._store.get(key, None)","def get(self, key):\n return self._store.get(key, None)","def get(self, key, default=None):\r\n return self.data.get(IdentityRef(key),default)","def get(self, key):\n\n node = self._get_node(key) # Get the node with the key (if it exists)\n\n if node is None:\n return None\n else:\n return node.value","def __getitem__(self, key: str) -> str:\n return self.get(key)","def get(self, key: str) -> Optional[Value]:\n\n return self._blob.get(key)","def __getitem__(self, key):\n self.__check_key_validity(key)\n return self.data[key[0]][key[1]]","def get(self, key, value_type=ByteString):\n value_type = Value.ensure_value_type(value_type,\n parameter='value_type')\n return value_type.load_value(self, key)","def _get_tagged_value(self, key):\n return self._tagged_values_dict[key]","def get(self, key):\n if key in self.fields:\n return self.fields.get(key).get()\n return None","def data(self, key):\n with self._cv:\n _, val = self._get(key)\n return val.data","def lookup(self, key):\n n = self.find(key)\n if n:\n return n.value\n else:\n return False","def value_for_index(self, index):\r\n return self[self.keyOrder[index]]","def getitem(value, key):\n try:\n return value[key]\n except Exception:\n return \"\"","def __getitem__(self, key):\n _, kv_pair = self._lookup(key, self._backing)\n if kv_pair:\n return kv_pair.value\n else:\n return Hashmap.absent","def __getitem__(self, key):\n return self._dict[key]","def get(self, key, default=None):","def get(self, key: str):\r\n\r\n if key in self._inner_dict:\r\n return self._inner_dict[key]\r\n else:\r\n raise KeyError(f\"key '{key}' is invalid\")","def find_value(dic, key):\n return dic[key]","def get(self, key):\n\n return self.dict_props.get(key)","def get(self, key):\n return self._cache[key]","def get_value(key):\n\n request_dict = RequestFileCom.file_to_dict()\n\n try:\n\n return request_dict[key]\n\n except:\n\n return None","def get(self, key, default=None):\n return self.data.get(key, default)","def get(self, key, default=None):\n return self.data.get(key, default)","def __getitem__(self, key):\n return self.__data[key]","def get_value(key, obj, default=missing):\n if isinstance(key, int):\n return _get_value_for_key(key, obj, default)\n return _get_value_for_keys(key.split('.'), obj, default)","def __getitem__(self, key):\n\n return self.fvals[key]","def __getitem__(self, key):\n return self.data[key]","def __getitem__(self, key):\n return self.data[key]","def __getitem__(self, key):\n return self.data[key]","def __getitem__(self, key):\n return self._[key]","def get(self, key):\r\n\t\t# return None if the key doesn't exist\r\n\t\tif not self.contains_key(key):\r\n\t\t\treturn None\r\n\t\telse:\r\n\t\t\tindex = self.get_index(key) # get the index of the key\r\n\r\n\t\t\t# begin traversal of the linked list until we reach the key\r\n\t\t\tcur_node = self._buckets[index].head\r\n\t\t\twhile cur_node.key != key:\r\n\t\t\t\tcur_node = cur_node.next\r\n\r\n\t\t\treturn cur_node.value","def get(self, key):\n return self._user_data.get(key)","def __getitem__(self, key: ir.Value) -> ir.Value:\n return ops.MapGet(self, key).to_expr()","def get(self, key: t.Hashable) -> t.Any:","def getValueByKey(self, key):\n if key in self.keys:\n print \"GOT \" + str(self.keyToValue[key])\n # Put the key to the end of the list since it is just called\n self.keys.remove(key) \n self.keys.append(key)\n else:\n print \"NOTFOUND\"","def _get(self, key):\n try:\n val = getattr(self, f\"_{key}\")\n if val is not None:\n return val\n else:\n self._load()\n return getattr(self, f\"_{key}\")\n except AttributeError:\n return None","def get(self, key: int) -> int:\n if key in self.keys:\n return self.values[self.keys.index(key)]\n else:\n return -1","def get(self, key):\n _filter = {'_id': key}\n doc = self.collection.find_one(_filter)\n\n if doc and not self._verify_timeout(doc):\n return self._unpickle(doc['value'])","def get(self, key):\n hi = self.hash_index(key)\n if (self.storage[hi]):\n if(self.storage[hi].next):\n current = self.storage[hi]\n while current.next and current.key != key:\n current = current.next\n return current.value\n else:\n return self.storage[hi].value\n\n return None","def get(self, key, default=None):\n result = self._get_raw_input().get(key, default)\n return result[0] if isinstance(result, list) else result","def get(self, key):\n pass","def __getitem__(self, key):\n return self.get_field(key)","def _get_value(self, key: Text) -> Any:\n value = self._container_status_dict.get(key)\n if value is None:\n # return an empty string for printing in the log\n return \"\"\n\n return value","def __getitem__(self, key):\r\n return self.data[key]","def __getitem__(self, key):\n return self._d[key]","def get(self, key):\n hashv = self.hash(key)\n bucket=self.hashmap[hashv]\n for i,(k,v) in enumerate(bucket):\n if k==key:\n return v\n return -1","def get_value(self, key, getter=lambda x: x):\n record_trie = self._record_trie\n assert key in record_trie\n value = record_trie[key]\n # Record trie allows keys to have multiple values and returns a list of values for each key.\n # As we make the value for each key a list already (to control order/not have to sort again),\n # we need to assert there is only a single value\n assert len(value) == 1\n value = value[0]\n return_value = inverse_qid_cand_with_score(value=value, itos=self._itos)\n res = list(map(getter, return_value))\n assert len(res) <= self._max_value\n return res","def retrieve(self, key):\n index = self._hash_mod(key)\n node = self.storage[index]\n while node is not None:\n if node.key == key:\n return node.value\n node = node.next\n return None"],"string":"[\n \"def get_value(self, key):\\n pass\",\n \"def get_value(self, key):\\n return self[key]\",\n \"def get_value(self, key):\\n return self.data.get(key)\",\n \"def get_value(self, key):\\n return self[key]['value']\",\n \"def get( self, key ):\\n if key not in self._values:\\n raise ValueError( 'Invalid argument key \\\"{}\\\".'.format( key ) )\\n return self._values[ key ]\",\n \"def get(self, key):\\n return self[key]\",\n \"def get(self, key):\\n\\t\\treturn self.__get(key, key[1:])\",\n \"def value(self, key):\\n item = self.default(key)\\n return self.__getSafeValue(key, item)\",\n \"def get_value(self, key):\\n try:\\n return self.map[key]\\n except KeyError:\\n raise KeyError('key is not in map')\",\n \"def get(self, key):\\n h = key%self.m\\n a = self.a\\n if a[h]:\\n return a[h].val\\n else:\\n return -1\",\n \"def __getitem__(self, key):\\n return self.keyvaluepair_set.get(key=key).value\",\n \"def get_value(self, key: str) -> Optional[str]:\\n raise NotImplementedError\",\n \"def get_value(self, key: str) -> Any:\\r\\n if key is None:\\r\\n return self.data\\r\\n try:\\r\\n return self.data[key]\\r\\n except KeyError:\\r\\n return None\",\n \"def get(self, key):\",\n \"def get(self, key):\",\n \"def get(self, key):\\n return self.arr[key]\",\n \"def get_value(key):\\n\\n oErr = ErrHandle()\\n infoval = None\\n try:\\n obj = TsgInfo.objects.filter(infokey__iexact=key).first()\\n if obj != None:\\n infoval = obj.infoval\\n except:\\n msg = oErr.get_error_message()\\n oErr.DoError(\\\"TsgInfo/get_value\\\")\\n return infoval\",\n \"def GetValue(self, key):\\n return self._metadata_dict[key]\",\n \"def get(self, key):\\n try:\\n return(self._data[key])\\n except:\\n log.error(\\\"Can't get data '%s'\\\" % key)\\n return\",\n \"async def get(self, key):\\n return self.dict.get(key, None)\",\n \"def get(self, key):\\n pass\",\n \"def get(self, key):\\n return self.sp.get(key)\",\n \"def get_value(self, conn, key):\\n if self.exists(conn, key):\\n return conn.get(key)\\n else:\\n raise Exception, \\\"No key (%s) exists\\\" %key\",\n \"def __getitem__(self, key):\\n return self.params[key].value\",\n \"def get(self, key):\\n if type(key) != str:\\n raise TypeError(\\\"This is not the string you're looking for!\\\")\\n number = self._hash(key)\\n stored_key = number if self.function == 'fnv' else key\\n try:\\n return self.bucket_list[number % self.bucket_number].search(stored_key).stored_value\\n except AttributeError:\\n return None\",\n \"def getKeyValue(self,\\n key,\\n no = 0):\\n keyword = key + \\\"___\\\" + str(no + 1)\\n return self.__keyObjs[keyword].getValue()\",\n \"def get(self, key: K) -> Optional[V]:\\n return self.mget([key])[0]\",\n \"def get(self, key):\\n # TODO: Check if the given key exists and return its associated value\\n hash_key = self._bucket_index(key) # Gets the index of the key\\n\\n if self.buckets[hash_key].is_empty() is False: # If the hask_key exists\\n for key_value_pair in self.buckets[hash_key]: # Iteratre through the value pair\\n if key_value_pair[0] is key: # If the key matches\\n return key_value_pair[1] # Return the value\\n raise KeyError(\\\"Key doesn't exist\\\") # If key doesn't exist, return None\",\n \"def get_value(self, key):\\r\\n if self.hash_table[self.horner_hash(key)] is not None:\\r\\n if self.hash_table[self.horner_hash(key)].key == key:\\r\\n return self.hash_table[self.horner_hash(key)].value\\r\\n else:\\r\\n return None\",\n \"def __getitem__(self, key):\\n\\n return self.values[key]\",\n \"def __getitem__(self, key):\\n return self._get(key)\",\n \"def get(self, key):\\r\\n if not isinstance(key, str):\\r\\n raise TypeError(\\\"Key must be a string\\\")\\r\\n\\r\\n node = self._find_node(key)\\r\\n if node is None:\\r\\n return None\\r\\n else:\\r\\n return node.value[1]\",\n \"def get(key):\\n return current().values[key]\",\n \"def __getitem__(self, key):\\n ndx = self._findPosition(key)\\n assert ndx is not None, 'Invalid map key'\\n return self._entryList[ndx].value\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def get(self, key):\\n raise NotImplementedError\",\n \"def get(self, key):\\n return self.container[key]\",\n \"def get_value(self, key):\\n if key not in self._config:\\n raise ValueError(\\\"%s not in self.config\\\"%key)\\n return self._config[key][\\\"value\\\"]\",\n \"def get(self, key):\\n hash_key = key % self.key_space\\n return self.hash_table[hash_key].get(key)\",\n \"def get(self, key):\\n return self.execute_command(self.GET_CMD, key)\",\n \"def get_value(dct, key):\\n return dct.get(key)\",\n \"def __getitem__(self, key):\\n return self.parameters[key].value\",\n \"def __getitem__(self, key):\\n return self.data.get(key, '')\",\n \"def get(self, key, default=None):\\n key = self._validate_key(key)\\n sql = u\\\"\\\"\\\"\\n SELECT `value` FROM `{table}` WHERE key = ?\\n \\\"\\\"\\\".format(table=self.name)\\n\\n r = self.conn.execute(sql, (key,)).fetchone()\\n\\n if r:\\n return self.convert_out(r['value'])\\n\\n return default\",\n \"def get(self, key):\\n node = self._get_node(key)\\n\\n if node:\\n return node.data\",\n \"def get(self, key):\\n return getattr(self, key)\",\n \"def get_value(self, key: Union[str, ConfigurationVariable]) -> Any:\\n if not key:\\n raise KeyError(key)\\n key_str = key.name if isinstance(key, ConfigurationVariable) else key\\n return self._fetch_value(key_str)\",\n \"def _get(self, key: str):\\n pass\",\n \"def get(self, key):\\n # Find bucket where given key belongs\\n # Check if key-value entry exists in bucket\\n # If found, return value associated with given key\\n # Otherwise, raise error to tell user get failed\\n # Hint: raise KeyError('Key not found: {}'.format(key))\\n key_bucket = self._bucket_index(key)\\n\\n for key_value_tuple in self.buckets[key_bucket].items():\\n if key_value_tuple[0] is key:\\n return key_value_tuple[1]\\n\\n raise KeyError('Key not found: {}'.format(key))\",\n \"def get(self, key: str) -> str:\\n hashkey = self._gethash(key)\\n if type(self.HashMap[hashkey]) is list:\\n if len(self.HashMap[hashkey]) > 2:\\n \\\"\\\"\\\"\\n Return correct Key and value from the\\n location which has a hashclash\\n \\\"\\\"\\\"\\n idx = self._find_if_hashclash(key, hashkey, \\\"v\\\")\\n if idx is not None:\\n return self.HashMap[hashkey][idx]\\n elif self.HashMap[hashkey][0] == key:\\n # Check that the data matches the key and return it if it does\\n return self.HashMap[hashkey][1]\\n return \\\"\\\"\",\n \"def get(self, key):\\n return self._store.get(key, None)\",\n \"def get(self, key):\\n return self._store.get(key, None)\",\n \"def get(self, key, default=None):\\r\\n return self.data.get(IdentityRef(key),default)\",\n \"def get(self, key):\\n\\n node = self._get_node(key) # Get the node with the key (if it exists)\\n\\n if node is None:\\n return None\\n else:\\n return node.value\",\n \"def __getitem__(self, key: str) -> str:\\n return self.get(key)\",\n \"def get(self, key: str) -> Optional[Value]:\\n\\n return self._blob.get(key)\",\n \"def __getitem__(self, key):\\n self.__check_key_validity(key)\\n return self.data[key[0]][key[1]]\",\n \"def get(self, key, value_type=ByteString):\\n value_type = Value.ensure_value_type(value_type,\\n parameter='value_type')\\n return value_type.load_value(self, key)\",\n \"def _get_tagged_value(self, key):\\n return self._tagged_values_dict[key]\",\n \"def get(self, key):\\n if key in self.fields:\\n return self.fields.get(key).get()\\n return None\",\n \"def data(self, key):\\n with self._cv:\\n _, val = self._get(key)\\n return val.data\",\n \"def lookup(self, key):\\n n = self.find(key)\\n if n:\\n return n.value\\n else:\\n return False\",\n \"def value_for_index(self, index):\\r\\n return self[self.keyOrder[index]]\",\n \"def getitem(value, key):\\n try:\\n return value[key]\\n except Exception:\\n return \\\"\\\"\",\n \"def __getitem__(self, key):\\n _, kv_pair = self._lookup(key, self._backing)\\n if kv_pair:\\n return kv_pair.value\\n else:\\n return Hashmap.absent\",\n \"def __getitem__(self, key):\\n return self._dict[key]\",\n \"def get(self, key, default=None):\",\n \"def get(self, key: str):\\r\\n\\r\\n if key in self._inner_dict:\\r\\n return self._inner_dict[key]\\r\\n else:\\r\\n raise KeyError(f\\\"key '{key}' is invalid\\\")\",\n \"def find_value(dic, key):\\n return dic[key]\",\n \"def get(self, key):\\n\\n return self.dict_props.get(key)\",\n \"def get(self, key):\\n return self._cache[key]\",\n \"def get_value(key):\\n\\n request_dict = RequestFileCom.file_to_dict()\\n\\n try:\\n\\n return request_dict[key]\\n\\n except:\\n\\n return None\",\n \"def get(self, key, default=None):\\n return self.data.get(key, default)\",\n \"def get(self, key, default=None):\\n return self.data.get(key, default)\",\n \"def __getitem__(self, key):\\n return self.__data[key]\",\n \"def get_value(key, obj, default=missing):\\n if isinstance(key, int):\\n return _get_value_for_key(key, obj, default)\\n return _get_value_for_keys(key.split('.'), obj, default)\",\n \"def __getitem__(self, key):\\n\\n return self.fvals[key]\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def __getitem__(self, key):\\n return self._[key]\",\n \"def get(self, key):\\r\\n\\t\\t# return None if the key doesn't exist\\r\\n\\t\\tif not self.contains_key(key):\\r\\n\\t\\t\\treturn None\\r\\n\\t\\telse:\\r\\n\\t\\t\\tindex = self.get_index(key) # get the index of the key\\r\\n\\r\\n\\t\\t\\t# begin traversal of the linked list until we reach the key\\r\\n\\t\\t\\tcur_node = self._buckets[index].head\\r\\n\\t\\t\\twhile cur_node.key != key:\\r\\n\\t\\t\\t\\tcur_node = cur_node.next\\r\\n\\r\\n\\t\\t\\treturn cur_node.value\",\n \"def get(self, key):\\n return self._user_data.get(key)\",\n \"def __getitem__(self, key: ir.Value) -> ir.Value:\\n return ops.MapGet(self, key).to_expr()\",\n \"def get(self, key: t.Hashable) -> t.Any:\",\n \"def getValueByKey(self, key):\\n if key in self.keys:\\n print \\\"GOT \\\" + str(self.keyToValue[key])\\n # Put the key to the end of the list since it is just called\\n self.keys.remove(key) \\n self.keys.append(key)\\n else:\\n print \\\"NOTFOUND\\\"\",\n \"def _get(self, key):\\n try:\\n val = getattr(self, f\\\"_{key}\\\")\\n if val is not None:\\n return val\\n else:\\n self._load()\\n return getattr(self, f\\\"_{key}\\\")\\n except AttributeError:\\n return None\",\n \"def get(self, key: int) -> int:\\n if key in self.keys:\\n return self.values[self.keys.index(key)]\\n else:\\n return -1\",\n \"def get(self, key):\\n _filter = {'_id': key}\\n doc = self.collection.find_one(_filter)\\n\\n if doc and not self._verify_timeout(doc):\\n return self._unpickle(doc['value'])\",\n \"def get(self, key):\\n hi = self.hash_index(key)\\n if (self.storage[hi]):\\n if(self.storage[hi].next):\\n current = self.storage[hi]\\n while current.next and current.key != key:\\n current = current.next\\n return current.value\\n else:\\n return self.storage[hi].value\\n\\n return None\",\n \"def get(self, key, default=None):\\n result = self._get_raw_input().get(key, default)\\n return result[0] if isinstance(result, list) else result\",\n \"def get(self, key):\\n pass\",\n \"def __getitem__(self, key):\\n return self.get_field(key)\",\n \"def _get_value(self, key: Text) -> Any:\\n value = self._container_status_dict.get(key)\\n if value is None:\\n # return an empty string for printing in the log\\n return \\\"\\\"\\n\\n return value\",\n \"def __getitem__(self, key):\\r\\n return self.data[key]\",\n \"def __getitem__(self, key):\\n return self._d[key]\",\n \"def get(self, key):\\n hashv = self.hash(key)\\n bucket=self.hashmap[hashv]\\n for i,(k,v) in enumerate(bucket):\\n if k==key:\\n return v\\n return -1\",\n \"def get_value(self, key, getter=lambda x: x):\\n record_trie = self._record_trie\\n assert key in record_trie\\n value = record_trie[key]\\n # Record trie allows keys to have multiple values and returns a list of values for each key.\\n # As we make the value for each key a list already (to control order/not have to sort again),\\n # we need to assert there is only a single value\\n assert len(value) == 1\\n value = value[0]\\n return_value = inverse_qid_cand_with_score(value=value, itos=self._itos)\\n res = list(map(getter, return_value))\\n assert len(res) <= self._max_value\\n return res\",\n \"def retrieve(self, key):\\n index = self._hash_mod(key)\\n node = self.storage[index]\\n while node is not None:\\n if node.key == key:\\n return node.value\\n node = node.next\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8878386","0.88521105","0.86971056","0.8678441","0.829813","0.8179047","0.8178329","0.8177001","0.8166392","0.8132502","0.8081488","0.80803794","0.8015064","0.7961579","0.7961579","0.78647137","0.78497577","0.78319174","0.77768177","0.7714798","0.7693951","0.7693264","0.7685313","0.76480925","0.76353526","0.76215917","0.76125634","0.7578197","0.75755084","0.7560126","0.754954","0.75388455","0.7520145","0.7516799","0.75154257","0.75154257","0.75154257","0.75110745","0.7504629","0.74942577","0.7486602","0.747911","0.7475026","0.7470837","0.74699366","0.7467351","0.74523336","0.7430529","0.7426767","0.7410506","0.73900676","0.737736","0.7361421","0.7361421","0.7353231","0.73530626","0.7351879","0.7346423","0.7339959","0.7327774","0.731361","0.7303195","0.7295189","0.7282451","0.7270698","0.7270582","0.725998","0.7259944","0.7242395","0.7238112","0.72130615","0.7201467","0.7199054","0.71979004","0.71772015","0.71772015","0.71708894","0.7162485","0.71599656","0.71533895","0.71533895","0.71533895","0.7151765","0.7143272","0.7135579","0.71332043","0.71318144","0.71246994","0.71066785","0.7100269","0.7096098","0.7090216","0.7073552","0.7072662","0.705796","0.7054842","0.7049129","0.70463437","0.7043896","0.7032814","0.7027704"],"string":"[\n \"0.8878386\",\n \"0.88521105\",\n \"0.86971056\",\n \"0.8678441\",\n \"0.829813\",\n \"0.8179047\",\n \"0.8178329\",\n \"0.8177001\",\n \"0.8166392\",\n \"0.8132502\",\n \"0.8081488\",\n \"0.80803794\",\n \"0.8015064\",\n \"0.7961579\",\n \"0.7961579\",\n \"0.78647137\",\n \"0.78497577\",\n \"0.78319174\",\n \"0.77768177\",\n \"0.7714798\",\n \"0.7693951\",\n \"0.7693264\",\n \"0.7685313\",\n \"0.76480925\",\n \"0.76353526\",\n \"0.76215917\",\n \"0.76125634\",\n \"0.7578197\",\n \"0.75755084\",\n \"0.7560126\",\n \"0.754954\",\n \"0.75388455\",\n \"0.7520145\",\n \"0.7516799\",\n \"0.75154257\",\n \"0.75154257\",\n \"0.75154257\",\n \"0.75110745\",\n \"0.7504629\",\n \"0.74942577\",\n \"0.7486602\",\n \"0.747911\",\n \"0.7475026\",\n \"0.7470837\",\n \"0.74699366\",\n \"0.7467351\",\n \"0.74523336\",\n \"0.7430529\",\n \"0.7426767\",\n \"0.7410506\",\n \"0.73900676\",\n \"0.737736\",\n \"0.7361421\",\n \"0.7361421\",\n \"0.7353231\",\n \"0.73530626\",\n \"0.7351879\",\n \"0.7346423\",\n \"0.7339959\",\n \"0.7327774\",\n \"0.731361\",\n \"0.7303195\",\n \"0.7295189\",\n \"0.7282451\",\n \"0.7270698\",\n \"0.7270582\",\n \"0.725998\",\n \"0.7259944\",\n \"0.7242395\",\n \"0.7238112\",\n \"0.72130615\",\n \"0.7201467\",\n \"0.7199054\",\n \"0.71979004\",\n \"0.71772015\",\n \"0.71772015\",\n \"0.71708894\",\n \"0.7162485\",\n \"0.71599656\",\n \"0.71533895\",\n \"0.71533895\",\n \"0.71533895\",\n \"0.7151765\",\n \"0.7143272\",\n \"0.7135579\",\n \"0.71332043\",\n \"0.71318144\",\n \"0.71246994\",\n \"0.71066785\",\n \"0.7100269\",\n \"0.7096098\",\n \"0.7090216\",\n \"0.7073552\",\n \"0.7072662\",\n \"0.705796\",\n \"0.7054842\",\n \"0.7049129\",\n \"0.70463437\",\n \"0.7043896\",\n \"0.7032814\",\n \"0.7027704\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14883,"cells":{"query":{"kind":"string","value":"Verifies that the appears in page title"},"document":{"kind":"string","value":"def is_title_matches(self):\n return \"EXNESS - Trader Calculator and Currency Converter\" in self.driver.title"},"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 check_title(self):\n currenttitle = self.driver.title\n assert self.TITLE in currenttitle, 'Title not expected. Actual: ' + currenttitle + ', Expected: ' + self.TITLE","def verifyPageTitle(self, titleToVerify):\n try:\n actualTitle = self.getTitle()\n return self.util.verifyTextContains(actualTitle, titleToVerify)\n except:\n self.log.error(\"Failed to get page title\")\n print_stack()\n return False","def page_title(step, title):\r\n\r\n with AssertContextManager(step):\r\n assert_equals(world.browser.title, title)","def test_home_page_title(self):\n response = self.client.get('/')\n self.assertIn(site_main_title, response.content.title().decode())","def is_title_displayed(self):\n return self.driver.wait_for_title_contains(InboxLocators.TITLE, 30)","def test_title(self):\n key = api.portal.get_registry_record(\n 'plone.site_title'\n )\n self.assertEqual(u'Briefy CMS', key)","def istitle(self) -> bool:\n pass","def test_sites_has_sites_in_title(self):\n self.browser.get(self.warno_url)\n self.browser.find_element_by_link_text(\"Sites\").click()\n self.assertTrue('Site' in self.browser.title, 'Sites did not have \"Site\" in title.')","def _is_title(self):\n ph = _child(self.__nvXxPr.nvPr, 'p:ph')\n if ph is None:\n return False\n # idx defaults to 0 when idx attr is absent\n ph_idx = ph.get('idx', '0')\n # title placeholder is identified by idx of 0\n return ph_idx == '0'","def testFalseCapTitle(self):\n val = capTitles(\"victor Ifezue\") \n self.assertNotEqual(val, \"victor Ifezue\")","def test_title(self):\n self.driver.get(\"https://demo.testchameleon.com/\")\n assert \"Gentellela Alela!\" in self.driver.title","def test_users_has_users_in_title(self):\n self.browser.get(self.warno_url)\n self.browser.find_element_by_link_text(\"Users\").click()\n self.assertTrue('User' in self.browser.title, 'Users did not have \"User\" in title')","def test_article_has_no_page_title(self, fake_article_missing_elements):\n\n fake_analysis = PageTitleAnalyzer(title=fake_article_missing_elements.title)\n assert not fake_analysis.has_page_title()","def test_article_has_page_title(self, fake_article):\n\n fake_analysis = PageTitleAnalyzer(title=fake_article.title)\n assert fake_analysis.has_page_title()","def is_bad_title(title):\n bad_examples = [\"under construction\", \"test page\", \"redirect\", \"index of\", \"none \", \"expired\", \"coming soon\",\n \"error \", \"domain pending\", \"at directnic\", \"pending validation\", \"website disabled\",\n \"US Zip Code Information\", # verified we need this, urls like 00000.us, 00001.us end up at zipcode.com\n \"domain default page\", \"non-existent domain\", \"v-webs hosting services\",\n \"be back soon\", \"something went wrong\", \"Lunarpages Web Hosting Placeholder Page\",\n \"Félicitations ! Votre domaine a bien été créé chez OVH !\", \"Domaine réservé\",\n \" - For Sale | Undeveloped\", \"Yahoo's Aabaco Small Business: Websites, Ecommerce, Email & Local Listings\",\n \"service unavailable\", \"website disabled\", \"404 Not Found\", \"Not Found\", \"Page cannot be found\"\n ]\n for bad_title in bad_examples:\n if bad_title.lower() in title.lower():\n debug(bad_title)\n return hit(bad_title)\n\n exact_matches = [\"web hosting\", \"webhosting\"]\n for ma in exact_matches:\n if title.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\").replace(\"\\r\", \"\").lower() == ma:\n debug(ma)\n return hit(ma)\n return False","def checkTitle(self,event=None):\r\n if self.title.getVal() not in self.titleList:\r\n self.titleList.append(self.title.getVal())\r\n self.titleList.sort()\r\n self.title.updateVals(self.titleList)","def test_query_has_query_in_title(self):\n query_url = self.warno_url + '/query'\n self.browser.get(query_url)\n self.assertTrue('Query' in self.browser.title, 'Query did not have \"Query\" in title')","def __Verify(self):\n if not self.title:\n raise db.Error('Missing title; required.')","def is_title_matches(self):\n return \"Python\" in self.driver.title","def test_instruments_has_instruments_in_title(self):\n self.browser.get(self.warno_url)\n self.browser.find_element_by_link_text(\"Instruments\").click()\n self.assertTrue('Instrument' in self.browser.title, 'Instruments did not have \"Instrument\" in title')","def test_title(names):","def valid_title(self, title):\n if title in self.timers.keys() and isinstance(title, str) and self.timers[title]['count']>0:\n return True\n else:\n return False","def test_dashboard_has_dashboard_in_title(self):\n self.browser.get(self.warno_url)\n self.browser.find_element_by_link_text(\"Dashboard\").click()\n self.assertTrue('Dashboard' in self.browser.title, 'Dashboard did not have \"Dashboard\" in title')","def titleValidator(self, title):\n if type(title) != str:\n API.abort(400, error_messages[11]['Int_title'])\n\n # check if the contents of title have characters between a-z and A-Z\n elif not re.match(r\"(^[a-zA-Z_]+$)\", title) or title.isspace():\n API.abort(\n 400, error_messages[12]['wrong_format_title'])\n\n return True","def test_submit_log_has_submit_log_in_title(self):\n self.browser.get(self.warno_url)\n self.browser.find_element_by_link_text(\"Submit Log\").click()\n self.assertTrue('Submit Log' in self.browser.title, 'Submit Log did not have \"Submit Log\" in title')","def handle_title(self, tag, attrs):\n self.title = 'present'","def set_title(self, title):\n if check_data_exist(title) is True:\n self.title = title.text","def test_get_title(double_title, single_title, empty_title):\n assert get_title(double_title) == \"Parton distributions with LHC data\"\n assert get_title(single_title) == \"The Large Hadron Collider\"\n assert get_title(empty_title) == \"\"\n\n no_title_key = {\n \"not_titles\": []\n }\n assert get_title(no_title_key) == \"\"","def validateTitle(title):\n \n if not(title) or not(title.strip()):\n return \"You must supply a title.\"\n else:\n return None","def validate_title_input(title):\n if len(title) != 0:\n clear()\n return True\n\n else:\n clear()\n print('** Please enter a task title **')\n return False","def check_valid_title(title):\n title_issues = TitleIssues(title_contains_nsfw=title_contains_nsfw(title))\n return title_issues","def test_title(self):\n self.assertEquals(\"Title\\n=====\", trans(\"== Title ==\"))\n self.assertEquals(\"Title\\n-----\", trans(\"=== Title ===\"))\n self.assertEquals(\"#### Title\", trans(\"==== Title ====\"))\n self.assertEquals(\"##### Title\", trans(\"===== Title =====\"))","def test_print_title_negativie(capsys, title, result):\n GC.print_title(title)\n out, err = capsys.readouterr()\n print(err)\n assert out != result","def title_exists(form, field):\n if Entry.select().where(Entry.title ** field.data).exists():\n raise ValidationError('That title is already in use.')","def test_ena_site_has_ena_in_title_and_is_accessible_through_sites_list(self):\n site_name = \"ENA\"\n self.browser.get(self.warno_url)\n self.browser.find_element_by_link_text(\"Sites\").click()\n self.browser.find_element_by_link_text(site_name).click()\n sub_title = self.browser.find_element_by_class_name(\"sub-title\")\n self.assertTrue(site_name in sub_title.text, 'Site %s did not have \"%s\" in sub-title' % (site_name, site_name))","def test_list_views_check_main_title_descriptin(self):\n url = reverse('blogs:list')\n response = self.client.get(url)\n # TODO you need to check that the tiles are present in the list Dilshad. You are only looking for the http200\n self.assertEqual(response.status_code, 200)\n self.assertIn(self.main_title, str(response.content))\n self.assertIn(self.description1, str(response.content))\n self.assertIn(self.description2, str(response.content))","def test_titles_do_not_match(self):\r\n gm_title = 'Zhao Hua'\r\n sp_title = 'MMXXX (ft Moor Mother)'\r\n self.assertFalse(gmspotify.titles_match(gm_title, sp_title))","def test_address__home_page_address_title__1(zcmlS):\n assert u'none' == ITitle(HomePageAddress())","def getTitle(self): #$NON-NLS-1$\r","def getTitle(self): #$NON-NLS-1$\r","def _validate_title(self, attribute: attr.Attribute, value: str):\n\n if not isinstance(value, str) or len(value) <= 0:\n raise ValueError(\n f\"Window title must be a non-empty string, received {value!r}\"\n )","def title_postfix(self):\n if not self.site:\n logger.warn(\"No site: %r\", self.site)\n return \"(not linked into a site!)\"\n return ''","def page_title_contains(self, title: str, timeout: TimeoutType = DEFAULT_TIMEOUT):\n return self._wait_until(condition=ec.title_contains(title), timeout=timeout)","def test_required_fields_title(self):\n\n del self.validator.adata.uns[\"title\"]\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors, [\"ERROR: 'title' in 'uns' is not present.\"]\n )","def is_title_matches(self):\n return \"Cryptocurrency Market Capitalizations\" in self.driver.title","def test_index_title(self):\n response = self.app.get('/')\n assert \"<title>Welcome to TurboGears</title>\" in response.body","def test_tags_request_title(self):\n page, page_2 = self.get_pages()\n\n # Assign tags to title\n title_tags = models.TitleTags.objects.create(extended_object=page.get_title_obj(\"en\"))\n title_tags.tags.add(*self.tag_strings)\n for lang in self.languages:\n page.publish(lang)\n\n site_id = page.node.site_id\n\n # Reload page from request and extract tags from it\n request = self.get_request(page, \"en\")\n tags_list = get_title_tags_from_request(request, page.get_public_object().pk, \"en\", site_id)\n self.assertEqual(set(self.tag_strings), {tag.name for tag in tags_list})","def get_title():","def _visit_title(self, elem):\n pass","def test_title(self):\n\n # list instead of string\n self.validator.adata.uns[\"title\"] = [\"title\"]\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors,\n [\n \"ERROR: '['title']' in 'uns['title']' is not valid, \"\n \"it must be a string.\"\n ],\n )","def test_Entry_title(self):\n test_entry = self.create_Entry()\n self.assertTrue(test_entry.title == str(test_entry))","def test_job_title(self):\n inv_search = 'title:engineer not title:programmer'\n spi_search = 'find job engineer not position programmer'\n self._compare_searches(inv_search, spi_search)","def test_ena_site_has_ena_in_title_and_is_accessible_through_instruments_list(self):\n site_name = \"ENA\"\n self.browser.get(self.warno_url)\n self.browser.find_element_by_link_text(\"Instruments\").click()\n self.browser.find_element_by_link_text(site_name).click()\n sub_title = self.browser.find_element_by_class_name(\"sub-title\")\n self.assertTrue(site_name in sub_title.text, 'Site %s did not have \"%s\" in sub-title' % (site_name, site_name))","def Show_Titles( self ):\r\n self.system.Change_Seq( \"Title\" )","def title(self):\n\t\treturn self.page_title","def test_title_handling(self, site_setup):\n templates, content, output, s_gen = site_setup\n\n templates.join(\"t.html\").write(\"{{ title }}\")\n templates.join(\"b.html\").write(\n \"{{ breadcrumbs|map(attribute='title')|join(', ') }}\"\n )\n\n with_title = content.mkdir(\"with-title\")\n with_title.join(\"index.md\").write(\"\\n\".join([\n \"template: t.html\",\n \"title: custom title\",\n \"---\"\n ]))\n with_title.join(\"child.md\").write(\"\\n\".join([\n \"template: b.html\",\n \"title: woohoo\",\n \"---\"\n ]))\n content.join(\"without-a-title.md\").write(\"\\n\".join([\n \"template: t.html\",\n \"---\"\n ]))\n\n s_gen.config[\"default_template\"] = \"t.html\"\n s_gen.gen_site(str(output))\n\n with_title_output = output.join(\"with-title\", \"index.html\")\n without_title_output = output.join(\"without-a-title\", \"index.html\")\n child_output = output.join(\"with-title\", \"child\", \"index.html\")\n # check the output files exist in the correct place\n assert with_title_output.check()\n assert without_title_output.check()\n assert child_output.check()\n\n assert with_title_output.read() == \"custom title\"\n assert without_title_output.read() == \"Without a title\"\n\n # Check that custom title is used in breadcrumbs\n exp_bc = \", \".join([HomePage.title, \"custom title\",\n \"woohoo\"])\n assert child_output.read() == exp_bc","def test_odd_title():\n test_string = \"And now to something completely different\"\n assert (test_string, \"\") == parse_title(test_string)","def testCapTitleAgain(self):\n val = capTitles(\"victor\") \n self.assertEqual(val, \"Victor\")","def test_basic(self):\n result = pdfmerger.strip_title(\"Interesting title (123) [321]\")\n self.assertEqual(\"Interesting title\", result)","def test_getTitle(self):\n def checkNameAndTitle(name, titlesolution):\n title = self._nameClassifierBuilder._getTitle(name)\n self.assertEquals(titlesolution, title)\n\n checkNameAndTitle(\"Mrs. ldajfhgp\", \"Mrs\")\n checkNameAndTitle(\"dlsfajkMrdlkjaf\", \"Mr\")\n checkNameAndTitle(\"dagddgwdasJonkheer\", \"Jonkheer\")","def appear_only_in_title(word, title, sents):\n assert (word in title), \"The word should be a title word\"\n \n for sent in sents:\n for w in sent:\n if w == word:\n return False\n return True","def doGetPageTitle(self, timeout=10.0):\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\n \n ret = True\n cmdId = self.getTitle()\n rsp = self.hasWindowTitle(timeout=timeout, commandId=cmdId)\n if rsp is None:\n ret = False\n else:\n elementVall = rsp.get('GUI', 'value')\n ret = elementVall.get('value') # title of the window\n return ret","def istitle(self):\n return istitle(self)","def test_print_title(capsys, title, result):\n GC.print_title(title)\n out, err = capsys.readouterr()\n print(err)\n assert out == result","def doFindTextPageTitle(self, expectedText, timeout=10.0):\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\n \n ret = True\n cmdId = self.getTitle()\n rsp = self.hasWindowTitle(timeout=timeout, commandId=cmdId, expectedText=expectedText)\n if rsp is None:\n ret = False\n return ret","def set_title(self, title):\n\t\tpass","def contained_in_title(word, filename):\n title = get_title(filename)\n if word in title:\n return True\n else:\n return False","def test_article_page_title_length(self, fake_article):\n\n fake_analysis = PageTitleAnalyzer(title=fake_article.title)\n assert fake_analysis.page_title_length == len(fake_article.title)","def _visit_title(self, elem):\n title_text = self._text_of(elem).strip()\n print \"document title=\"+ repr(title_text)\n\n # TODO update document title for document id self._curr_doc_id\n self._url_titles[self._curr_url] = title_text","def testCapTitle(self):\n val = capTitles(\"false true\") \n self.assertEqual(val, \"False True\")","def test_home_page_is_displayed_with_chrome(self):\n self.browser.get(self.live_server_url)\n page_title = self.browser.find_element_by_tag_name('h1').text,\n 'DU GRAS, OUI MAIS DE QUALITÉ'\n self.assertEqual(\n page_title[0], 'DU GRAS, OUI MAIS DE QUALITÉ'\n )","def test_index_has_status_in_title(self):","def check_title(title_list):\n for w_index in range(len(title_list)):\n title_list[w_index] = title_list[w_index].replace('_', ' ')\n return [word for word in title_list if word.istitle()]","def test_login_title(self):\n response = self.app.get('/login')\n assert \"<title>Login</title>\" in response\n assert \"Please log in.\" in response\n assert \"session cookies\" not in response\n assert \"credentials\" not in response\n assert \"not correct\" not in response","def title_p(self):\n self.run_command('title_p')","def test_content(test):\n # from bs4 import BeautifulSoup\n # assert 'GitHub' in BeautifulSoup(response.content).title.string","def test_custom_title_umap(self):\n umap = UMAPVisualizer(title=\"custom_title\")\n\n assert umap.title == \"custom_title\"","def test_get_book_title(self):\n\t\t\n\t\tself.assertTrue(data.get_book_title(46) == '1 Corinthians')","def test_google_exists(self):\n\t\tself.driver.get(\"http://www.google.com\")\n\t\tself.assertIn(\"Google\", self.driver.title)","def settitle(self, title):\n self.__title = title\n self.__nonzero = True","def test_very_long_title( self ):\n driver = self.driver\n driver.get(self.base_url + \"/record=b5713050~S6\")\n driver.find_element_by_link_text(\"Request\").click()\n url_obj = urlparse( driver.current_url )\n q_dct = parse_qs( driver.current_url )\n # print( 'q_dct, ```%s```' % pprint.pformat(q_dct) )\n self.assertEqual(\n 'jcbl.aeon.atlas-sys.com',\n url_obj.netloc )\n self.assertEqual(\n ['b5713050'],\n q_dct['ReferenceNumber'] )\n self.assertEqual(\n [\"The English-American his travail by sea and land: or, A new survey of the West-India's [sic], : containing a journall of three thousand and three hundred miles within the main land of America. Wher...\"],\n q_dct['ItemTitle'] )\n self.assertEqual(\n ['Gage, Thomas, 1603?-1656'],\n q_dct['ItemAuthor'] )\n self.assertEqual(\n ['London : printed by R. Cotes, and are to be sold by Humphrey Blunden at the Castle in Cornhill, and Thomas Williams at the Bible in Little Britain, 1648'],\n q_dct['ItemPublisher'] )\n self.assertEqual(\n ['1-SIZE D648 .G133e'],\n q_dct['CallNumber'] )\n self.assertEqual(\n ['http://www.archive.org/details/englishamericanh00gage'],\n q_dct['ItemInfo2'] )","def _check_title(self, other):\n if not isinstance(other, CellRange):\n raise TypeError(repr(type(other)))\n\n if other.title and self.title != other.title:\n raise ValueError(\"Cannot work with ranges from different worksheets\")","def get_page_title(self):\n return self.driver.get_title()","def get_valid_title(title):\n if len(title) >= 254:\n title = title[:254]\n return title","def _verify_page(self):","def lower_in_title(word, filename):\n title = get_title(filename)\n if word.lower() in title.lower():\n return True\n else:\n return False","def lookup_space(self, title=None, **kwargs):\n return False","def has_story_title(self, title, stories):\n\tfor story in stories:\n\t break\n\telse:\n\t self.fail(\"Story with title '%s' not found\" % title)","def has_story_title(self, title, stories):\n\tfor story in stories:\n\t break\n\telse:\n\t self.fail(\"Story with title '%s' not found\" % title)","def test_content(response):\n # from bs4 import BeautifulSoup\n # assert 'GitHub' in BeautifulSoup(response.content).title.string\n assert True","def hasWindowTitle(self, timeout=20.0, commandId=None, expectedText=None):\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\n \n valueLayer = TestTemplates.TemplateLayer(name=\"\")\n if expectedText is not None:\n valueLayer.addKey(name=\"value\", data=expectedText)\n return self.isActionAccepted(timeout=timeout, commandName=Command.GET_TITLE, \n commandId=commandId, expectedValue=valueLayer)","def test_missing_title(self):\n self.is_authenticated()\n response = self.post_without_title()\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)","def check_for_metatitle(self, interest_name: str):\n if interest_name.endswith(\"/streaming/p*\"):\n return True\n else:\n return False","def test_getTitle(self):\n path = os.sep.join([self.module_path, \"eaccpf\"])\n cases = [\n (path + os.sep + 'markup_in_title_1.xml', \"Anglicare Victoria\"),\n (path + os.sep + 'markup_in_title_2.xml', \"Anglicare Victoria - Corporate Body\"),\n (path + os.sep + 'markup_in_title_3.xml', \"Anglicare Victoria (1984/1)\"),\n (path + os.sep + 'markup_in_title_4.xml', \"Anglicare Victoria (1984/1) - Corporate Body\"),\n ]\n for case in cases:\n source, expected = case\n doc = EacCpf.EacCpf(source, 'http://www.findandconnect.gov.au', 'http://www.findandconnect.gov.au')\n self.assertNotEqual(None, doc)\n result = doc.getTitle()\n self.assertEqual(expected, result)","def check_title(title_list):\r\n\tnew_list = [] #Initialize a new list\r\n\tfor title in title_list: # iterates through the list to look for the non-titles\r\n\t\tif title.istitle(): # checks for titles\r\n\t\t\tnew_list.append(title) # if found, appends to the new list\r\n\treturn new_list # returns the new appended list.\r","def test_content(response):\n # from bs4 import BeautifulSoup\n # assert 'GitHub' in BeautifulSoup(response.content).title.string","def test_content(response):\n # from bs4 import BeautifulSoup\n # assert 'GitHub' in BeautifulSoup(response.content).title.string","def test_content(response):\n # from bs4 import BeautifulSoup\n # assert 'GitHub' in BeautifulSoup(response.content).title.string","def test_content(response):\n # from bs4 import BeautifulSoup\n # assert 'GitHub' in BeautifulSoup(response.content).title.string","def test_content(response):\n # from bs4 import BeautifulSoup\n # assert 'GitHub' in BeautifulSoup(response.content).title.string"],"string":"[\n \"def check_title(self):\\n currenttitle = self.driver.title\\n assert self.TITLE in currenttitle, 'Title not expected. Actual: ' + currenttitle + ', Expected: ' + self.TITLE\",\n \"def verifyPageTitle(self, titleToVerify):\\n try:\\n actualTitle = self.getTitle()\\n return self.util.verifyTextContains(actualTitle, titleToVerify)\\n except:\\n self.log.error(\\\"Failed to get page title\\\")\\n print_stack()\\n return False\",\n \"def page_title(step, title):\\r\\n\\r\\n with AssertContextManager(step):\\r\\n assert_equals(world.browser.title, title)\",\n \"def test_home_page_title(self):\\n response = self.client.get('/')\\n self.assertIn(site_main_title, response.content.title().decode())\",\n \"def is_title_displayed(self):\\n return self.driver.wait_for_title_contains(InboxLocators.TITLE, 30)\",\n \"def test_title(self):\\n key = api.portal.get_registry_record(\\n 'plone.site_title'\\n )\\n self.assertEqual(u'Briefy CMS', key)\",\n \"def istitle(self) -> bool:\\n pass\",\n \"def test_sites_has_sites_in_title(self):\\n self.browser.get(self.warno_url)\\n self.browser.find_element_by_link_text(\\\"Sites\\\").click()\\n self.assertTrue('Site' in self.browser.title, 'Sites did not have \\\"Site\\\" in title.')\",\n \"def _is_title(self):\\n ph = _child(self.__nvXxPr.nvPr, 'p:ph')\\n if ph is None:\\n return False\\n # idx defaults to 0 when idx attr is absent\\n ph_idx = ph.get('idx', '0')\\n # title placeholder is identified by idx of 0\\n return ph_idx == '0'\",\n \"def testFalseCapTitle(self):\\n val = capTitles(\\\"victor Ifezue\\\") \\n self.assertNotEqual(val, \\\"victor Ifezue\\\")\",\n \"def test_title(self):\\n self.driver.get(\\\"https://demo.testchameleon.com/\\\")\\n assert \\\"Gentellela Alela!\\\" in self.driver.title\",\n \"def test_users_has_users_in_title(self):\\n self.browser.get(self.warno_url)\\n self.browser.find_element_by_link_text(\\\"Users\\\").click()\\n self.assertTrue('User' in self.browser.title, 'Users did not have \\\"User\\\" in title')\",\n \"def test_article_has_no_page_title(self, fake_article_missing_elements):\\n\\n fake_analysis = PageTitleAnalyzer(title=fake_article_missing_elements.title)\\n assert not fake_analysis.has_page_title()\",\n \"def test_article_has_page_title(self, fake_article):\\n\\n fake_analysis = PageTitleAnalyzer(title=fake_article.title)\\n assert fake_analysis.has_page_title()\",\n \"def is_bad_title(title):\\n bad_examples = [\\\"under construction\\\", \\\"test page\\\", \\\"redirect\\\", \\\"index of\\\", \\\"none \\\", \\\"expired\\\", \\\"coming soon\\\",\\n \\\"error \\\", \\\"domain pending\\\", \\\"at directnic\\\", \\\"pending validation\\\", \\\"website disabled\\\",\\n \\\"US Zip Code Information\\\", # verified we need this, urls like 00000.us, 00001.us end up at zipcode.com\\n \\\"domain default page\\\", \\\"non-existent domain\\\", \\\"v-webs hosting services\\\",\\n \\\"be back soon\\\", \\\"something went wrong\\\", \\\"Lunarpages Web Hosting Placeholder Page\\\",\\n \\\"Félicitations ! Votre domaine a bien été créé chez OVH !\\\", \\\"Domaine réservé\\\",\\n \\\" - For Sale | Undeveloped\\\", \\\"Yahoo's Aabaco Small Business: Websites, Ecommerce, Email & Local Listings\\\",\\n \\\"service unavailable\\\", \\\"website disabled\\\", \\\"404 Not Found\\\", \\\"Not Found\\\", \\\"Page cannot be found\\\"\\n ]\\n for bad_title in bad_examples:\\n if bad_title.lower() in title.lower():\\n debug(bad_title)\\n return hit(bad_title)\\n\\n exact_matches = [\\\"web hosting\\\", \\\"webhosting\\\"]\\n for ma in exact_matches:\\n if title.replace(\\\" \\\", \\\"\\\").replace(\\\"\\\\t\\\", \\\"\\\").replace(\\\"\\\\n\\\", \\\"\\\").replace(\\\"\\\\r\\\", \\\"\\\").lower() == ma:\\n debug(ma)\\n return hit(ma)\\n return False\",\n \"def checkTitle(self,event=None):\\r\\n if self.title.getVal() not in self.titleList:\\r\\n self.titleList.append(self.title.getVal())\\r\\n self.titleList.sort()\\r\\n self.title.updateVals(self.titleList)\",\n \"def test_query_has_query_in_title(self):\\n query_url = self.warno_url + '/query'\\n self.browser.get(query_url)\\n self.assertTrue('Query' in self.browser.title, 'Query did not have \\\"Query\\\" in title')\",\n \"def __Verify(self):\\n if not self.title:\\n raise db.Error('Missing title; required.')\",\n \"def is_title_matches(self):\\n return \\\"Python\\\" in self.driver.title\",\n \"def test_instruments_has_instruments_in_title(self):\\n self.browser.get(self.warno_url)\\n self.browser.find_element_by_link_text(\\\"Instruments\\\").click()\\n self.assertTrue('Instrument' in self.browser.title, 'Instruments did not have \\\"Instrument\\\" in title')\",\n \"def test_title(names):\",\n \"def valid_title(self, title):\\n if title in self.timers.keys() and isinstance(title, str) and self.timers[title]['count']>0:\\n return True\\n else:\\n return False\",\n \"def test_dashboard_has_dashboard_in_title(self):\\n self.browser.get(self.warno_url)\\n self.browser.find_element_by_link_text(\\\"Dashboard\\\").click()\\n self.assertTrue('Dashboard' in self.browser.title, 'Dashboard did not have \\\"Dashboard\\\" in title')\",\n \"def titleValidator(self, title):\\n if type(title) != str:\\n API.abort(400, error_messages[11]['Int_title'])\\n\\n # check if the contents of title have characters between a-z and A-Z\\n elif not re.match(r\\\"(^[a-zA-Z_]+$)\\\", title) or title.isspace():\\n API.abort(\\n 400, error_messages[12]['wrong_format_title'])\\n\\n return True\",\n \"def test_submit_log_has_submit_log_in_title(self):\\n self.browser.get(self.warno_url)\\n self.browser.find_element_by_link_text(\\\"Submit Log\\\").click()\\n self.assertTrue('Submit Log' in self.browser.title, 'Submit Log did not have \\\"Submit Log\\\" in title')\",\n \"def handle_title(self, tag, attrs):\\n self.title = 'present'\",\n \"def set_title(self, title):\\n if check_data_exist(title) is True:\\n self.title = title.text\",\n \"def test_get_title(double_title, single_title, empty_title):\\n assert get_title(double_title) == \\\"Parton distributions with LHC data\\\"\\n assert get_title(single_title) == \\\"The Large Hadron Collider\\\"\\n assert get_title(empty_title) == \\\"\\\"\\n\\n no_title_key = {\\n \\\"not_titles\\\": []\\n }\\n assert get_title(no_title_key) == \\\"\\\"\",\n \"def validateTitle(title):\\n \\n if not(title) or not(title.strip()):\\n return \\\"You must supply a title.\\\"\\n else:\\n return None\",\n \"def validate_title_input(title):\\n if len(title) != 0:\\n clear()\\n return True\\n\\n else:\\n clear()\\n print('** Please enter a task title **')\\n return False\",\n \"def check_valid_title(title):\\n title_issues = TitleIssues(title_contains_nsfw=title_contains_nsfw(title))\\n return title_issues\",\n \"def test_title(self):\\n self.assertEquals(\\\"Title\\\\n=====\\\", trans(\\\"== Title ==\\\"))\\n self.assertEquals(\\\"Title\\\\n-----\\\", trans(\\\"=== Title ===\\\"))\\n self.assertEquals(\\\"#### Title\\\", trans(\\\"==== Title ====\\\"))\\n self.assertEquals(\\\"##### Title\\\", trans(\\\"===== Title =====\\\"))\",\n \"def test_print_title_negativie(capsys, title, result):\\n GC.print_title(title)\\n out, err = capsys.readouterr()\\n print(err)\\n assert out != result\",\n \"def title_exists(form, field):\\n if Entry.select().where(Entry.title ** field.data).exists():\\n raise ValidationError('That title is already in use.')\",\n \"def test_ena_site_has_ena_in_title_and_is_accessible_through_sites_list(self):\\n site_name = \\\"ENA\\\"\\n self.browser.get(self.warno_url)\\n self.browser.find_element_by_link_text(\\\"Sites\\\").click()\\n self.browser.find_element_by_link_text(site_name).click()\\n sub_title = self.browser.find_element_by_class_name(\\\"sub-title\\\")\\n self.assertTrue(site_name in sub_title.text, 'Site %s did not have \\\"%s\\\" in sub-title' % (site_name, site_name))\",\n \"def test_list_views_check_main_title_descriptin(self):\\n url = reverse('blogs:list')\\n response = self.client.get(url)\\n # TODO you need to check that the tiles are present in the list Dilshad. You are only looking for the http200\\n self.assertEqual(response.status_code, 200)\\n self.assertIn(self.main_title, str(response.content))\\n self.assertIn(self.description1, str(response.content))\\n self.assertIn(self.description2, str(response.content))\",\n \"def test_titles_do_not_match(self):\\r\\n gm_title = 'Zhao Hua'\\r\\n sp_title = 'MMXXX (ft Moor Mother)'\\r\\n self.assertFalse(gmspotify.titles_match(gm_title, sp_title))\",\n \"def test_address__home_page_address_title__1(zcmlS):\\n assert u'none' == ITitle(HomePageAddress())\",\n \"def getTitle(self): #$NON-NLS-1$\\r\",\n \"def getTitle(self): #$NON-NLS-1$\\r\",\n \"def _validate_title(self, attribute: attr.Attribute, value: str):\\n\\n if not isinstance(value, str) or len(value) <= 0:\\n raise ValueError(\\n f\\\"Window title must be a non-empty string, received {value!r}\\\"\\n )\",\n \"def title_postfix(self):\\n if not self.site:\\n logger.warn(\\\"No site: %r\\\", self.site)\\n return \\\"(not linked into a site!)\\\"\\n return ''\",\n \"def page_title_contains(self, title: str, timeout: TimeoutType = DEFAULT_TIMEOUT):\\n return self._wait_until(condition=ec.title_contains(title), timeout=timeout)\",\n \"def test_required_fields_title(self):\\n\\n del self.validator.adata.uns[\\\"title\\\"]\\n self.validator.validate_adata()\\n self.assertEqual(\\n self.validator.errors, [\\\"ERROR: 'title' in 'uns' is not present.\\\"]\\n )\",\n \"def is_title_matches(self):\\n return \\\"Cryptocurrency Market Capitalizations\\\" in self.driver.title\",\n \"def test_index_title(self):\\n response = self.app.get('/')\\n assert \\\"<title>Welcome to TurboGears</title>\\\" in response.body\",\n \"def test_tags_request_title(self):\\n page, page_2 = self.get_pages()\\n\\n # Assign tags to title\\n title_tags = models.TitleTags.objects.create(extended_object=page.get_title_obj(\\\"en\\\"))\\n title_tags.tags.add(*self.tag_strings)\\n for lang in self.languages:\\n page.publish(lang)\\n\\n site_id = page.node.site_id\\n\\n # Reload page from request and extract tags from it\\n request = self.get_request(page, \\\"en\\\")\\n tags_list = get_title_tags_from_request(request, page.get_public_object().pk, \\\"en\\\", site_id)\\n self.assertEqual(set(self.tag_strings), {tag.name for tag in tags_list})\",\n \"def get_title():\",\n \"def _visit_title(self, elem):\\n pass\",\n \"def test_title(self):\\n\\n # list instead of string\\n self.validator.adata.uns[\\\"title\\\"] = [\\\"title\\\"]\\n self.validator.validate_adata()\\n self.assertEqual(\\n self.validator.errors,\\n [\\n \\\"ERROR: '['title']' in 'uns['title']' is not valid, \\\"\\n \\\"it must be a string.\\\"\\n ],\\n )\",\n \"def test_Entry_title(self):\\n test_entry = self.create_Entry()\\n self.assertTrue(test_entry.title == str(test_entry))\",\n \"def test_job_title(self):\\n inv_search = 'title:engineer not title:programmer'\\n spi_search = 'find job engineer not position programmer'\\n self._compare_searches(inv_search, spi_search)\",\n \"def test_ena_site_has_ena_in_title_and_is_accessible_through_instruments_list(self):\\n site_name = \\\"ENA\\\"\\n self.browser.get(self.warno_url)\\n self.browser.find_element_by_link_text(\\\"Instruments\\\").click()\\n self.browser.find_element_by_link_text(site_name).click()\\n sub_title = self.browser.find_element_by_class_name(\\\"sub-title\\\")\\n self.assertTrue(site_name in sub_title.text, 'Site %s did not have \\\"%s\\\" in sub-title' % (site_name, site_name))\",\n \"def Show_Titles( self ):\\r\\n self.system.Change_Seq( \\\"Title\\\" )\",\n \"def title(self):\\n\\t\\treturn self.page_title\",\n \"def test_title_handling(self, site_setup):\\n templates, content, output, s_gen = site_setup\\n\\n templates.join(\\\"t.html\\\").write(\\\"{{ title }}\\\")\\n templates.join(\\\"b.html\\\").write(\\n \\\"{{ breadcrumbs|map(attribute='title')|join(', ') }}\\\"\\n )\\n\\n with_title = content.mkdir(\\\"with-title\\\")\\n with_title.join(\\\"index.md\\\").write(\\\"\\\\n\\\".join([\\n \\\"template: t.html\\\",\\n \\\"title: custom title\\\",\\n \\\"---\\\"\\n ]))\\n with_title.join(\\\"child.md\\\").write(\\\"\\\\n\\\".join([\\n \\\"template: b.html\\\",\\n \\\"title: woohoo\\\",\\n \\\"---\\\"\\n ]))\\n content.join(\\\"without-a-title.md\\\").write(\\\"\\\\n\\\".join([\\n \\\"template: t.html\\\",\\n \\\"---\\\"\\n ]))\\n\\n s_gen.config[\\\"default_template\\\"] = \\\"t.html\\\"\\n s_gen.gen_site(str(output))\\n\\n with_title_output = output.join(\\\"with-title\\\", \\\"index.html\\\")\\n without_title_output = output.join(\\\"without-a-title\\\", \\\"index.html\\\")\\n child_output = output.join(\\\"with-title\\\", \\\"child\\\", \\\"index.html\\\")\\n # check the output files exist in the correct place\\n assert with_title_output.check()\\n assert without_title_output.check()\\n assert child_output.check()\\n\\n assert with_title_output.read() == \\\"custom title\\\"\\n assert without_title_output.read() == \\\"Without a title\\\"\\n\\n # Check that custom title is used in breadcrumbs\\n exp_bc = \\\", \\\".join([HomePage.title, \\\"custom title\\\",\\n \\\"woohoo\\\"])\\n assert child_output.read() == exp_bc\",\n \"def test_odd_title():\\n test_string = \\\"And now to something completely different\\\"\\n assert (test_string, \\\"\\\") == parse_title(test_string)\",\n \"def testCapTitleAgain(self):\\n val = capTitles(\\\"victor\\\") \\n self.assertEqual(val, \\\"Victor\\\")\",\n \"def test_basic(self):\\n result = pdfmerger.strip_title(\\\"Interesting title (123) [321]\\\")\\n self.assertEqual(\\\"Interesting title\\\", result)\",\n \"def test_getTitle(self):\\n def checkNameAndTitle(name, titlesolution):\\n title = self._nameClassifierBuilder._getTitle(name)\\n self.assertEquals(titlesolution, title)\\n\\n checkNameAndTitle(\\\"Mrs. ldajfhgp\\\", \\\"Mrs\\\")\\n checkNameAndTitle(\\\"dlsfajkMrdlkjaf\\\", \\\"Mr\\\")\\n checkNameAndTitle(\\\"dagddgwdasJonkheer\\\", \\\"Jonkheer\\\")\",\n \"def appear_only_in_title(word, title, sents):\\n assert (word in title), \\\"The word should be a title word\\\"\\n \\n for sent in sents:\\n for w in sent:\\n if w == word:\\n return False\\n return True\",\n \"def doGetPageTitle(self, timeout=10.0):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n ret = True\\n cmdId = self.getTitle()\\n rsp = self.hasWindowTitle(timeout=timeout, commandId=cmdId)\\n if rsp is None:\\n ret = False\\n else:\\n elementVall = rsp.get('GUI', 'value')\\n ret = elementVall.get('value') # title of the window\\n return ret\",\n \"def istitle(self):\\n return istitle(self)\",\n \"def test_print_title(capsys, title, result):\\n GC.print_title(title)\\n out, err = capsys.readouterr()\\n print(err)\\n assert out == result\",\n \"def doFindTextPageTitle(self, expectedText, timeout=10.0):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n ret = True\\n cmdId = self.getTitle()\\n rsp = self.hasWindowTitle(timeout=timeout, commandId=cmdId, expectedText=expectedText)\\n if rsp is None:\\n ret = False\\n return ret\",\n \"def set_title(self, title):\\n\\t\\tpass\",\n \"def contained_in_title(word, filename):\\n title = get_title(filename)\\n if word in title:\\n return True\\n else:\\n return False\",\n \"def test_article_page_title_length(self, fake_article):\\n\\n fake_analysis = PageTitleAnalyzer(title=fake_article.title)\\n assert fake_analysis.page_title_length == len(fake_article.title)\",\n \"def _visit_title(self, elem):\\n title_text = self._text_of(elem).strip()\\n print \\\"document title=\\\"+ repr(title_text)\\n\\n # TODO update document title for document id self._curr_doc_id\\n self._url_titles[self._curr_url] = title_text\",\n \"def testCapTitle(self):\\n val = capTitles(\\\"false true\\\") \\n self.assertEqual(val, \\\"False True\\\")\",\n \"def test_home_page_is_displayed_with_chrome(self):\\n self.browser.get(self.live_server_url)\\n page_title = self.browser.find_element_by_tag_name('h1').text,\\n 'DU GRAS, OUI MAIS DE QUALITÉ'\\n self.assertEqual(\\n page_title[0], 'DU GRAS, OUI MAIS DE QUALITÉ'\\n )\",\n \"def test_index_has_status_in_title(self):\",\n \"def check_title(title_list):\\n for w_index in range(len(title_list)):\\n title_list[w_index] = title_list[w_index].replace('_', ' ')\\n return [word for word in title_list if word.istitle()]\",\n \"def test_login_title(self):\\n response = self.app.get('/login')\\n assert \\\"<title>Login</title>\\\" in response\\n assert \\\"Please log in.\\\" in response\\n assert \\\"session cookies\\\" not in response\\n assert \\\"credentials\\\" not in response\\n assert \\\"not correct\\\" not in response\",\n \"def title_p(self):\\n self.run_command('title_p')\",\n \"def test_content(test):\\n # from bs4 import BeautifulSoup\\n # assert 'GitHub' in BeautifulSoup(response.content).title.string\",\n \"def test_custom_title_umap(self):\\n umap = UMAPVisualizer(title=\\\"custom_title\\\")\\n\\n assert umap.title == \\\"custom_title\\\"\",\n \"def test_get_book_title(self):\\n\\t\\t\\n\\t\\tself.assertTrue(data.get_book_title(46) == '1 Corinthians')\",\n \"def test_google_exists(self):\\n\\t\\tself.driver.get(\\\"http://www.google.com\\\")\\n\\t\\tself.assertIn(\\\"Google\\\", self.driver.title)\",\n \"def settitle(self, title):\\n self.__title = title\\n self.__nonzero = True\",\n \"def test_very_long_title( self ):\\n driver = self.driver\\n driver.get(self.base_url + \\\"/record=b5713050~S6\\\")\\n driver.find_element_by_link_text(\\\"Request\\\").click()\\n url_obj = urlparse( driver.current_url )\\n q_dct = parse_qs( driver.current_url )\\n # print( 'q_dct, ```%s```' % pprint.pformat(q_dct) )\\n self.assertEqual(\\n 'jcbl.aeon.atlas-sys.com',\\n url_obj.netloc )\\n self.assertEqual(\\n ['b5713050'],\\n q_dct['ReferenceNumber'] )\\n self.assertEqual(\\n [\\\"The English-American his travail by sea and land: or, A new survey of the West-India's [sic], : containing a journall of three thousand and three hundred miles within the main land of America. Wher...\\\"],\\n q_dct['ItemTitle'] )\\n self.assertEqual(\\n ['Gage, Thomas, 1603?-1656'],\\n q_dct['ItemAuthor'] )\\n self.assertEqual(\\n ['London : printed by R. Cotes, and are to be sold by Humphrey Blunden at the Castle in Cornhill, and Thomas Williams at the Bible in Little Britain, 1648'],\\n q_dct['ItemPublisher'] )\\n self.assertEqual(\\n ['1-SIZE D648 .G133e'],\\n q_dct['CallNumber'] )\\n self.assertEqual(\\n ['http://www.archive.org/details/englishamericanh00gage'],\\n q_dct['ItemInfo2'] )\",\n \"def _check_title(self, other):\\n if not isinstance(other, CellRange):\\n raise TypeError(repr(type(other)))\\n\\n if other.title and self.title != other.title:\\n raise ValueError(\\\"Cannot work with ranges from different worksheets\\\")\",\n \"def get_page_title(self):\\n return self.driver.get_title()\",\n \"def get_valid_title(title):\\n if len(title) >= 254:\\n title = title[:254]\\n return title\",\n \"def _verify_page(self):\",\n \"def lower_in_title(word, filename):\\n title = get_title(filename)\\n if word.lower() in title.lower():\\n return True\\n else:\\n return False\",\n \"def lookup_space(self, title=None, **kwargs):\\n return False\",\n \"def has_story_title(self, title, stories):\\n\\tfor story in stories:\\n\\t break\\n\\telse:\\n\\t self.fail(\\\"Story with title '%s' not found\\\" % title)\",\n \"def has_story_title(self, title, stories):\\n\\tfor story in stories:\\n\\t break\\n\\telse:\\n\\t self.fail(\\\"Story with title '%s' not found\\\" % title)\",\n \"def test_content(response):\\n # from bs4 import BeautifulSoup\\n # assert 'GitHub' in BeautifulSoup(response.content).title.string\\n assert True\",\n \"def hasWindowTitle(self, timeout=20.0, commandId=None, expectedText=None):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n valueLayer = TestTemplates.TemplateLayer(name=\\\"\\\")\\n if expectedText is not None:\\n valueLayer.addKey(name=\\\"value\\\", data=expectedText)\\n return self.isActionAccepted(timeout=timeout, commandName=Command.GET_TITLE, \\n commandId=commandId, expectedValue=valueLayer)\",\n \"def test_missing_title(self):\\n self.is_authenticated()\\n response = self.post_without_title()\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def check_for_metatitle(self, interest_name: str):\\n if interest_name.endswith(\\\"/streaming/p*\\\"):\\n return True\\n else:\\n return False\",\n \"def test_getTitle(self):\\n path = os.sep.join([self.module_path, \\\"eaccpf\\\"])\\n cases = [\\n (path + os.sep + 'markup_in_title_1.xml', \\\"Anglicare Victoria\\\"),\\n (path + os.sep + 'markup_in_title_2.xml', \\\"Anglicare Victoria - Corporate Body\\\"),\\n (path + os.sep + 'markup_in_title_3.xml', \\\"Anglicare Victoria (1984/1)\\\"),\\n (path + os.sep + 'markup_in_title_4.xml', \\\"Anglicare Victoria (1984/1) - Corporate Body\\\"),\\n ]\\n for case in cases:\\n source, expected = case\\n doc = EacCpf.EacCpf(source, 'http://www.findandconnect.gov.au', 'http://www.findandconnect.gov.au')\\n self.assertNotEqual(None, doc)\\n result = doc.getTitle()\\n self.assertEqual(expected, result)\",\n \"def check_title(title_list):\\r\\n\\tnew_list = [] #Initialize a new list\\r\\n\\tfor title in title_list: # iterates through the list to look for the non-titles\\r\\n\\t\\tif title.istitle(): # checks for titles\\r\\n\\t\\t\\tnew_list.append(title) # if found, appends to the new list\\r\\n\\treturn new_list # returns the new appended list.\\r\",\n \"def test_content(response):\\n # from bs4 import BeautifulSoup\\n # assert 'GitHub' in BeautifulSoup(response.content).title.string\",\n \"def test_content(response):\\n # from bs4 import BeautifulSoup\\n # assert 'GitHub' in BeautifulSoup(response.content).title.string\",\n \"def test_content(response):\\n # from bs4 import BeautifulSoup\\n # assert 'GitHub' in BeautifulSoup(response.content).title.string\",\n \"def test_content(response):\\n # from bs4 import BeautifulSoup\\n # assert 'GitHub' in BeautifulSoup(response.content).title.string\",\n \"def test_content(response):\\n # from bs4 import BeautifulSoup\\n # assert 'GitHub' in BeautifulSoup(response.content).title.string\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7973157","0.7904546","0.7394582","0.73098224","0.71877354","0.71312666","0.71010184","0.7058365","0.696883","0.6958025","0.6924629","0.69108593","0.68864435","0.68840015","0.6877334","0.68517303","0.6819171","0.6722788","0.6661423","0.66260976","0.6616025","0.66045755","0.6563417","0.65422803","0.651611","0.64702564","0.6467712","0.6461964","0.6461647","0.64599353","0.64396447","0.642905","0.6414856","0.63908607","0.63347757","0.631767","0.630892","0.62800694","0.62795687","0.62795687","0.6274775","0.62687844","0.6246558","0.6228198","0.6213631","0.6210168","0.6200139","0.61674166","0.61666846","0.61612546","0.61479384","0.6138828","0.61213493","0.61140114","0.61105055","0.61054474","0.6102235","0.61002123","0.6097721","0.60959977","0.609487","0.6057359","0.6055041","0.6043022","0.59903294","0.5980474","0.59696156","0.59693944","0.59685916","0.5963278","0.59382826","0.59352964","0.5920837","0.591889","0.5911427","0.59092766","0.5901284","0.58917177","0.58805597","0.5870242","0.5866324","0.5859128","0.5836215","0.58330387","0.5829707","0.581854","0.5811931","0.58020467","0.58020467","0.57969326","0.57966274","0.5758352","0.5756511","0.57547694","0.5736658","0.5736151","0.5736151","0.5736151","0.5736151","0.5736151"],"string":"[\n \"0.7973157\",\n \"0.7904546\",\n \"0.7394582\",\n \"0.73098224\",\n \"0.71877354\",\n \"0.71312666\",\n \"0.71010184\",\n \"0.7058365\",\n \"0.696883\",\n \"0.6958025\",\n \"0.6924629\",\n \"0.69108593\",\n \"0.68864435\",\n \"0.68840015\",\n \"0.6877334\",\n \"0.68517303\",\n \"0.6819171\",\n \"0.6722788\",\n \"0.6661423\",\n \"0.66260976\",\n \"0.6616025\",\n \"0.66045755\",\n \"0.6563417\",\n \"0.65422803\",\n \"0.651611\",\n \"0.64702564\",\n \"0.6467712\",\n \"0.6461964\",\n \"0.6461647\",\n \"0.64599353\",\n \"0.64396447\",\n \"0.642905\",\n \"0.6414856\",\n \"0.63908607\",\n \"0.63347757\",\n \"0.631767\",\n \"0.630892\",\n \"0.62800694\",\n \"0.62795687\",\n \"0.62795687\",\n \"0.6274775\",\n \"0.62687844\",\n \"0.6246558\",\n \"0.6228198\",\n \"0.6213631\",\n \"0.6210168\",\n \"0.6200139\",\n \"0.61674166\",\n \"0.61666846\",\n \"0.61612546\",\n \"0.61479384\",\n \"0.6138828\",\n \"0.61213493\",\n \"0.61140114\",\n \"0.61105055\",\n \"0.61054474\",\n \"0.6102235\",\n \"0.61002123\",\n \"0.6097721\",\n \"0.60959977\",\n \"0.609487\",\n \"0.6057359\",\n \"0.6055041\",\n \"0.6043022\",\n \"0.59903294\",\n \"0.5980474\",\n \"0.59696156\",\n \"0.59693944\",\n \"0.59685916\",\n \"0.5963278\",\n \"0.59382826\",\n \"0.59352964\",\n \"0.5920837\",\n \"0.591889\",\n \"0.5911427\",\n \"0.59092766\",\n \"0.5901284\",\n \"0.58917177\",\n \"0.58805597\",\n \"0.5870242\",\n \"0.5866324\",\n \"0.5859128\",\n \"0.5836215\",\n \"0.58330387\",\n \"0.5829707\",\n \"0.581854\",\n \"0.5811931\",\n \"0.58020467\",\n \"0.58020467\",\n \"0.57969326\",\n \"0.57966274\",\n \"0.5758352\",\n \"0.5756511\",\n \"0.57547694\",\n \"0.5736658\",\n \"0.5736151\",\n \"0.5736151\",\n \"0.5736151\",\n \"0.5736151\",\n \"0.5736151\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66116136"},"document_rank":{"kind":"string","value":"21"}}},{"rowIdx":14884,"cells":{"query":{"kind":"string","value":"Draw something into the buffer"},"document":{"kind":"string","value":"def draw_tiles(self):\n db = self.double_buffer\n if db is not None:\n span_x = self.width\n span_y = self.height\n tiles_x = int(ceil(span_x/256.0))\n tiles_y = int(ceil(span_y/256.0))\n\n cc = cairo.Context(db)\n tiles = self.tile_loader.load_area(self.longitude,self.latitude,self.zoom,tiles_x,tiles_y)\n tile_number=0\n line_number=0\n\n x_center = self.width/2# - 128\n y_center = self.height/2# - 128\n offset_x,offset_y = self.tile_loader.gmap_tile_xy_from_coord(self.longitude,self.latitude,self.zoom)\n\n\n xtiles = len(tiles[0])\n ytiles = len(tiles)\n #print len(tiles),len(tiles[0])\n for line in tiles:\n for tile in line:\n x = (tile_number - int(xtiles/2)) * 256 + x_center\n y = (line_number - int(ytiles/2)) * 256 + y_center\n finalx = x - offset_x #+128\n finaly = y - offset_y #+128\n cc.set_source_surface(tile, finalx+self.dx, finaly+self.dy)\n cc.paint()\n tile_number += 1\n tile_number = 0\n line_number += 1\n\n self.draw_cross(cc,x_center,y_center)\n self.draw_points(cc)\n\n db.flush()\n\n else:\n print('Invalid double buffer')"},"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 draw():","def draw(self, screen):","def draw(self):\n pass","def draw(self):\n pass","def draw(self):\n pass","def draw(self):\n pass","def draw(self):\n\t\tpass","def draw(self):","def draw(self):\n self.batch.draw()","def draw(self):\n raise NotImplementedError","def draw(self):\n raise NotImplementedError","def draw(self):\n raise NotImplementedError","def draw(self, screen, offsets: tuple):\r\n pass","def draw( self, **kw ):\n pass","def draw(self) -> Any:","def draw(self):\n self.write_image()\n self.update()","def on_draw(self):\n # Clearing the buffers\n self.clear()\n self.set3d()\n # Makes it so color can be added\n glColor3d(1, 1, 1)\n\n self.push(self.player.pos, self.player.rot)\n self.model.draw()\n glPopMatrix()\n self.model.process_queue_slowly()\n\n # Draws the crosshairs on the screen\n self.set2d()\n self.draw_position_label()\n self.draw_reticle()","def draw(self):\n with self:\n self.batch.draw()","def draw(self):\n #for (x, y) in self.coords:\n # pyxel.rect(\n # (x + self.x) * 4,\n # (y + self.y) * 4,\n # (x + self.x) * 4 + 3,\n # (y + self.y) * 4 + 3,\n # self.color)","def draw(self, screen):\n screen.blit(self.surface, self.rect)","def paint(self, draw, x, y, w, h):\n\t\tpass","def draw(self):\n ui.clear()\n ui.draw_board(self)\n ui.output_buffer()","def game_draw(self):\n pass","def draw(self, *args, **kwargs):\n self.window.clear()\n self.batch.draw()","def draw_sprite(self, buf, x, y, w, h):\n x2 = x + w - 1\n y2 = y + h - 1\n if self.is_off_grid(x, y, x2, y2):\n return\n self.set_window(x, y, x2, y2, buf)","def draw(self):\n if self.visible:\n glColor3f(self.r, self.g, self.b)\n graphicsBall(self.x, self.y, self.radius)\n\n if self.number <= 8:\n glColor3f(1.0, 1.0, 1.0)\n else:\n glColor3f(0.0, 0.0, 0.0)\n\n graphicsBall(self.x, self.y, self.radius / 2)\n\n if self.number > 0:\n if self.number > 8:\n glColor3f(1.0, 1.0, 1.0)\n else:\n glColor3f(0.0, 0.0, 0.0)\n\n if self.number < 10:\n graphicsText(self.x - 2, self.y - 3.5, str(self.number))\n else:\n graphicsText(self.x - 4.5, self.y - 3.5, str(self.number))","def draw(self):\n self.game.screen.blit(self.image, self.game.off(self.pos))","def on_draw(self, widget, cr):\n #print \"starting to draw\"\n if self.double_buffer is not None:\n self.draw_tiles()\n cr.set_source_surface(self.double_buffer, 0.0, 0.0)\n cr.paint()\n else:\n print('Invalid double buffer')\n #print \"done drawing\"\n return False","def draw(self):\n self.screen.blit(self.msg_image, self.msg_image_rect)","def draw(self):\n if self.state == 'alive':\n for i in range(len(self.tail)):\n pygame.draw.rect(display, black, (squareToXPix(self.tail[-(i + 1)][0], objectSize), squareToYPix(self.tail[-(i + 1)][1], objectSize), objectSize, objectSize))\n\n pygame.draw.rect(display, black, (squareToXPix(self.x, objectSize), squareToYPix(self.y, objectSize), objectSize, objectSize))\n\n else:\n for i in range(len(self.tail)):\n pygame.draw.rect(display, red, (squareToXPix(self.tail[-(i + 1)][0], objectSize), squareToYPix(self.tail[-(i + 1)][1], objectSize), objectSize, objectSize))\n\n pygame.draw.rect(display, red, (squareToXPix(self.x, objectSize), squareToYPix(self.y, objectSize), objectSize, objectSize))","def draw(self):\n arcade.draw_xywh_rectangle_filled(\n self.x, self.y, self.width, self.height, self.fill.color\n )\n arcade.draw_xywh_rectangle_outline(\n self.x, self.y, self.width, self.height, self.pen.color, 3\n )","def draw(self):\r\n if not self.stopped:\r\n super().draw()\r\n self.next_frame()","def draw(self):\n return ImageDraw.Draw(self.buffer)","def Draw(self):\n print ( 10*\"*\")\n print (\"Player \" + self.character + \" says:\")\n print (\"It's a Draw\")\n print ( 10*\"*\")","def draw(self):\n\n surf = self.get_oxygen_surface()\n surf.set_alpha(255)\n self.screen.blit(surf, self.pos)","def on_draw(self):\n # draw everything","def draw(self, win):\n self.rect.draw(win)\n self.text.draw(win)","def draw(self, surface, offset=(0,0)):\n mouse = pg.mouse.get_pos()\n pos = mouse[0]-offset[0], mouse[1]-offset[1]\n if self.clicked:\n fill_color = pg.Color(\"white\")\n text = self.selected_text\n elif self.rect.collidepoint(pos):\n fill_color = (198, 226, 255)\n text = self.selected_text\n else:\n fill_color = self.color\n text = self.text\n surface.fill(pg.Color(\"black\"), self.rect)\n surface.fill(fill_color, self.rect.inflate(-2,-2))\n surface.blit(text, self.text_rect)","def draw(self, offset: IntegerPosition2D, canvas: Canvas) -> None:\n canvas_position: IntegerPosition2D\n if not self.buffer:\n canvas_position = IntegerPosition2D(0, 0)\n else:\n row: int = self.buffer.get_row(self.index)\n column: int = self.buffer.get_column(self.index)\n canvas_position = IntegerPosition2D(column, row)\n canvas_position += offset\n\n if not 0 <= canvas_position.x < canvas.size.width:\n return\n\n if not 0 <= canvas_position.y < canvas.size.height:\n return\n\n canvas.invert(canvas_position)","def _blit(self):\n libtcod.console_blit(self.console, 0, 0, self.width,\n self.height, 0, 0, 0)","def _draw(self):\n\n pygame.draw.circle(self.display, self.colour,\n self.pos.astype(int),\n self.rad)\n pygame.draw.circle(self.display, black,\n self.pos.astype(int),\n self.rad, 2)","def draw(self, *args, **kwargs) -> np.ndarray:\n pass","def draw(self, shape):\n shape.draw(shader=self.shader)","def draw(self):\n self.ball_sprite.draw()","def on_draw(self):\n\t\tself.render()","def on_draw(self):\n\t\tself.render()","def draw(self):\n self.screen.blit(self.image, self.rect)","def draw(self, p):\r\n self.active = True\r\n surface = pygame.surfarray.make_surface(p)\r\n self.screen.blit(surface, (0, 0))\r\n pygame.display.flip()\r\n return","def Draw(self):\n\t\tGameImage.Draw(self, self.coords)","def draw(self):\n if self.is_clicked:\n pg.draw.circle(self.window, self.color, (self.x, self.y), self.r, 0)\n else:\n pg.draw.circle(self.window, self.color, (self.x, self.y), self.r, 1)","def draw():\n screen.fill((0, 0, 0))\n alien.draw()","def draw(self, cr, width, height):\n cr.set_source_rgb(0, 0, 0)\n cr.rectangle(0, 0, width, height)\n cr.fill()","def draw(self):\r\n self.__screen.draw_asteroid(self, self.__x, self.__y)","def draw(self):\n\n State.screen.draw()","def draw(self):\n if self.dirty or (self.image is None):\n self._render()\n self.screen.blit(self.image, self.rect)","def draw(self):\r\n pygame.draw.rect(self.screen, self.background_color, self.bounds)\r\n line_window = self.lines[self.scroll_window_top:self.scroll_window_bottom]\r\n for idx,line in enumerate(line_window):\r\n text = self.font.render(line, True, self.foreground_color)\r\n x,y = self._get_x_y_from_pos(self.position[0], self.position[1]+idx)\r\n self.screen.blit(text,(x,y))\r\n \r\n if self.cursor_visible and self.scroll_window_bottom == len(self.lines):\r\n x,y = self._get_x_y_from_pos(len(line_window[-1]), len(line_window))\r\n cursor_rect = pygame.Rect(x,y,\r\n self.text_width,self.text_height)\r\n pygame.draw.rect(self.screen, self.foreground_color, cursor_rect)","def draw(self):\n if self.type == 'Circle':\n pygame.draw.circle(self.screen, SIM_COLORS['blue'], \n (int(self._params[0]), int(self._params[1])), \n int(self._params[2]), \n 0)\n elif self.type == 'Line':\n pygame.draw.line(self.screen, SIM_COLORS['blue'],\n (int(self._params[0]), int(self._params[1])),\n (int(self._params[2]), int(self._params[3])), 5)\n elif self.type == 'Rect':\n pygame.draw.rect(self.screen, SIM_COLORS['blue'],\n (int(self._params[0]), int(self._params[1]),\n int(self._params[2]), int(self._params[3])) )","def draw(self):\n self.screen.fill(WHITE)\n self.color_invalid()\n self.draw_selected()\n self.shade_locked_cells()\n self.draw_grid()\n self.draw_buttons()\n self.draw_numbers()","def draw(self):\n arcade.draw_rectangle_outline(self.position_x, self.position_y, self.radius, self.color)","def draw(self, win):\n font = pygame.font.SysFont(\"comicsans\", 40)\n\n gap = self.width / 9\n x = self.col * gap\n y = self.row * gap\n\n if self.temp != 0 and self.value == 0:\n text = font.render(str(self.temp), 1, (128,128,128))\n win.blit(text, (x+5, y+5))\n elif not(self.value == 0):\n text = font.render(str(self.value), 1, (0, 0, 0))\n win.blit(text, (x + (gap/2 - text.get_width()/2), y + (gap/2 - text.get_height()/2)))\n\n if self.selected:\n pygame.draw.rect(win, (255,0,0), (x,y, gap ,gap), 3)","def draw(self):\n if (libt.map_is_in_fov(self.handler.fov_map, self.x, self.y) or \n self.handler.world.map[self.x][self.y].seen and self.visible_in_fog):\n libt.console_set_default_foreground(self.handler.game_map, self.colour)\n libt.console_put_char(self.handler.game_map, self.x, self.y, \n self.char, libt.BKGND_NONE)","def draw(self, thing):\n thing.draw(self, Point([2,2]), flip=1)\n\n # configure the scroll region\n bbox = Canvas.bbox(self.canvas, ALL)\n self.canvas.configure(scrollregion=bbox)","def draw(self):\n wave_counter = self.game.myfont.render(f\"Poziom: {self.wave_counter}\", False, (255, 255, 255))\n self.game.screen.blit(wave_counter, (5, 95))","def draw(self):\r\n self.screen.blit(self.image, self.image.get_rect())","def __draw(self, screen):\n\n pygame.draw.rect(screen, (200, 255, 200), (self.x, self.y, self.width, self.height))","def draw(self):\n # IMPLEMENT ME\n \"\"\"\n GRectangle(x=GAME_WIDTH/2,y=GAME_HEIGHT/2,\n width=GAME_WIDTH,height=GAME_HEIGHT,\n fillcolor=introcs.RGB(0,0,0)).draw(self.view)\n if self.getState() == STATE_INACTIVE:\n self.getText().draw(self.view)\n if self.getState() == STATE_PAUSED:\n self.getText().draw(self.view)\n if not self.getWave() is None:\n self.getWave().draw(self.view)\n if self.getState() == STATE_COMPLETE:\n self.getText().draw(self.view)\n if self.getState() == STATE_PAUSED or self.getState() == STATE_ACTIVE or self.getState() == STATE_COMPLETE:\n self.getText().draw(self.view)\n\n GRectangle(x=GAME_WIDTH/2,y=GAME_HEIGHT/2,\n width=GAME_WIDTH,height=GAME_HEIGHT,\n fillcolor=introcs.RGB(0,0,0)).draw(self.view)\"\"\"\n if not self.getText() is None:\n self.getText().draw(self.view)\n if not self.getWave() is None:\n self.getWave().draw(self.view)","def draw(self, color, x, y) -> None:\n y_pos = y * self.scale\n x_pos = x * self.scale\n pg.draw.rect(self.screen, color, [x_pos, y_pos, self.scale-self.offset, self.scale-self.offset])","def draw(self, surface, force=False):\n if self.redraw or force:\n surface.blit(self.image, self.loc)\n self.redraw = False","def draw_self(self):\n self.ball_sprite.draw()","def draw(self):\n if not self.pressed:\n #draw info prompt in room\n arcade.draw_rectangle_filled(self.center_x, self.center_y, 20, 20, arcade.color.ANTIQUE_BRASS)\n arcade.draw_text(\"?\", self.center_x, self.center_y, arcade.color.BLACK, anchor_x=\"center\", anchor_y=\"center\")\n else:\n #draw info to top of screen when clicked\n arcade.draw_text(self.text, 10, settings.HEIGHT - 10, arcade.color.BLACK, anchor_x=\"left\", anchor_y=\"top\")","def draw_me(self):\r\n\t\tself.image.fill((100, 200, 100))\r\n\t\tif self.active: pg.draw.rect(self.image, (100, 100, 200), self.frame, 3) #if active => draw frame around selected entity width 3\r\n\t\tself.display_surface.blit(self.image, self.rect)","def draw(screen):\n MY.restart_button.draw(screen)\n MY.display_text.draw(screen)","def draw(self):\n self.vertex_list.draw(pyglet.gl.GL_QUADS)\n self.label.draw()","def draw(self,renderer,dx,dy):\n for i in self.itemType.find('display'):\n if i.tag == 'rect':\n colors = i.find('color').text[1:-1].split(',')\n SDL_SetRenderDrawColor(renderer,int(colors[0]),int(colors[1]),int(colors[2]),int(colors[3]) if len(colors) > 3 else 255)\n rect = SDL_Rect()\n rect.x, rect.y = self.getPos()\n rect.x, rect.y = rect.x+dx,rect.y+dy\n rect.w, rect.h = self.getSize()\n SDL_RenderFillRect(renderer,rect)","def pre_draw(self):","def draw(self, color = Color.GREEN):\n self.image[self.x, self.y] = color","def draw(self):\n if len(self.__points) >= 2:\n self._total_length = 0\n for i in range(len(self.__points) - 1):\n p1 = self.__points[i]\n p2 = self.__points[i + 1]\n coords = self.__line_segment(p1, p2)\n if not coords is None:\n pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,\n [0, 1, 2, 1, 2, 3],\n ('v2i', coords),\n ('c4b', self.color * 4)\n )\n coords = self.__line_cap(p2)\n pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,\n [0, 1, 2, 0, 2, 3],\n ('v2i', coords),\n ('c4b', self.color * 4)\n )","def draw(self):\n arcade.draw_circle_filled(self.position_x, self.position_y, self.radius,self.player_color)","def _draw(self, canvas, options):\n pass # must override in subclass","def draw(self):\n self.screen.blit(self.image, (self.x_pos1, self.y_pos))\n self.screen.blit(self.image, (self.x_pos2, self.y_pos))","def draw(self, surface):\r\n surface.blit(self.image, self.rect)","def draw(self, win):\n pygame.draw.rect(win, self.color, self.rect)","def draw(self, surface):\n surface.blit(self.image, self.rect)","def draw(self, surface):\n surface.blit(self.image, self.rect)","def draw(self, surface):\r\n if self.visible:\r\n surface.blit(self.image, (self.x, self.y))","def draw(self):\n\n self.state_stack.peek().draw(self.screen)","def draw(self):\n return self._myCanvas.draw()","def on_draw(self, screen):\n raise NotImplemented(\"on_draw method should be implemented.\")","def draw(self, force=False):\n self.display.draw(force)","def draw( self ):\n\t\t\t\n\t\ttransposition = lambda point: (point[0] + WINDOW_X, WINDOW_Y - point[1])\n\t\t\t \n\t\tx, y = transposition( self.position.xy )\n\t\tpygame.draw.circle(self.screen, self.color, ( int(x + 0.5), int(y + 0.5) ), self.r)","def draw(self):\n self.bufferX = (self.appWidth/2) - self.viewX\n self.bufferY = (self.appHeight/2) - self.viewY\n anwp.sl.engine.clear()\n anwp.sl.engine.drawImage(0, 0, self.appWidth, self.appHeight, self.backgroundImage)\n self.drawWarpLines()\n \n # render engine\n anwp.sl.engine.render()\n self.drawSystemInfo()\n self.drawWarpGateInfo()\n self.drawWarpTradeInfo()","def draw(self):\n self.screen.fill((0,51,102))\n # get the new drawables\n self.drawables = (self.game_model.get_background_drawables()\n + self.game_model.get_plane_drawables()\n + self.game_model.get_bullet_drawables()\n + self.game_model.get_enemy_drawables())\n for d in self.drawables:\n rect = d.get_rect()\n surf = d.get_surface()\n surf.set_colorkey((255,255,255))\n self.screen.blit(surf, rect)","def draw_brick(self, x, y):\n pygame.draw.rect(self.main_surface, self.color, (x, y, self.width, self.height), 0)\n pygame.display.update()","def draw(self, force = False):\n\t\tpass","def draw(self, renderer, *args, **kwargs):\n self.update_positions(renderer)","def render(self, game):\n pygame.draw.rect(game.screen,\n self.colour,\n (int(self.x), int(self.y), self.a, self.b))","def blit_buffer(self, buffer, x, y, width, height):\n self._set_window(x, y, x + width - 1, y + height - 1)\n self._write(None, buffer)","def draw(self):\n self.screen.fill(Color.BLACK)\n self.screen.blit(self.red_block, self.apple)\n [self.screen.blit(self.green_block, xy) for xy in self.snake]\n self.screen.blit(self.white_bar, (0, 0))\n self.draw_text(str(self.score), self.score_pos, size=32)\n pygame.display.flip()","def draw(self):\n if context.click():\n self.place()","def on_draw(self, da, ctx):\n self.referee.get_current_state().draw(ctx)","def draw(self):\r\n self.scr.fill(SCREEN_COLOR)\r\n self.label.draw()\r\n pygame.display.flip()"],"string":"[\n \"def draw():\",\n \"def draw(self, screen):\",\n \"def draw(self):\\n pass\",\n \"def draw(self):\\n pass\",\n \"def draw(self):\\n pass\",\n \"def draw(self):\\n pass\",\n \"def draw(self):\\n\\t\\tpass\",\n \"def draw(self):\",\n \"def draw(self):\\n self.batch.draw()\",\n \"def draw(self):\\n raise NotImplementedError\",\n \"def draw(self):\\n raise NotImplementedError\",\n \"def draw(self):\\n raise NotImplementedError\",\n \"def draw(self, screen, offsets: tuple):\\r\\n pass\",\n \"def draw( self, **kw ):\\n pass\",\n \"def draw(self) -> Any:\",\n \"def draw(self):\\n self.write_image()\\n self.update()\",\n \"def on_draw(self):\\n # Clearing the buffers\\n self.clear()\\n self.set3d()\\n # Makes it so color can be added\\n glColor3d(1, 1, 1)\\n\\n self.push(self.player.pos, self.player.rot)\\n self.model.draw()\\n glPopMatrix()\\n self.model.process_queue_slowly()\\n\\n # Draws the crosshairs on the screen\\n self.set2d()\\n self.draw_position_label()\\n self.draw_reticle()\",\n \"def draw(self):\\n with self:\\n self.batch.draw()\",\n \"def draw(self):\\n #for (x, y) in self.coords:\\n # pyxel.rect(\\n # (x + self.x) * 4,\\n # (y + self.y) * 4,\\n # (x + self.x) * 4 + 3,\\n # (y + self.y) * 4 + 3,\\n # self.color)\",\n \"def draw(self, screen):\\n screen.blit(self.surface, self.rect)\",\n \"def paint(self, draw, x, y, w, h):\\n\\t\\tpass\",\n \"def draw(self):\\n ui.clear()\\n ui.draw_board(self)\\n ui.output_buffer()\",\n \"def game_draw(self):\\n pass\",\n \"def draw(self, *args, **kwargs):\\n self.window.clear()\\n self.batch.draw()\",\n \"def draw_sprite(self, buf, x, y, w, h):\\n x2 = x + w - 1\\n y2 = y + h - 1\\n if self.is_off_grid(x, y, x2, y2):\\n return\\n self.set_window(x, y, x2, y2, buf)\",\n \"def draw(self):\\n if self.visible:\\n glColor3f(self.r, self.g, self.b)\\n graphicsBall(self.x, self.y, self.radius)\\n\\n if self.number <= 8:\\n glColor3f(1.0, 1.0, 1.0)\\n else:\\n glColor3f(0.0, 0.0, 0.0)\\n\\n graphicsBall(self.x, self.y, self.radius / 2)\\n\\n if self.number > 0:\\n if self.number > 8:\\n glColor3f(1.0, 1.0, 1.0)\\n else:\\n glColor3f(0.0, 0.0, 0.0)\\n\\n if self.number < 10:\\n graphicsText(self.x - 2, self.y - 3.5, str(self.number))\\n else:\\n graphicsText(self.x - 4.5, self.y - 3.5, str(self.number))\",\n \"def draw(self):\\n self.game.screen.blit(self.image, self.game.off(self.pos))\",\n \"def on_draw(self, widget, cr):\\n #print \\\"starting to draw\\\"\\n if self.double_buffer is not None:\\n self.draw_tiles()\\n cr.set_source_surface(self.double_buffer, 0.0, 0.0)\\n cr.paint()\\n else:\\n print('Invalid double buffer')\\n #print \\\"done drawing\\\"\\n return False\",\n \"def draw(self):\\n self.screen.blit(self.msg_image, self.msg_image_rect)\",\n \"def draw(self):\\n if self.state == 'alive':\\n for i in range(len(self.tail)):\\n pygame.draw.rect(display, black, (squareToXPix(self.tail[-(i + 1)][0], objectSize), squareToYPix(self.tail[-(i + 1)][1], objectSize), objectSize, objectSize))\\n\\n pygame.draw.rect(display, black, (squareToXPix(self.x, objectSize), squareToYPix(self.y, objectSize), objectSize, objectSize))\\n\\n else:\\n for i in range(len(self.tail)):\\n pygame.draw.rect(display, red, (squareToXPix(self.tail[-(i + 1)][0], objectSize), squareToYPix(self.tail[-(i + 1)][1], objectSize), objectSize, objectSize))\\n\\n pygame.draw.rect(display, red, (squareToXPix(self.x, objectSize), squareToYPix(self.y, objectSize), objectSize, objectSize))\",\n \"def draw(self):\\n arcade.draw_xywh_rectangle_filled(\\n self.x, self.y, self.width, self.height, self.fill.color\\n )\\n arcade.draw_xywh_rectangle_outline(\\n self.x, self.y, self.width, self.height, self.pen.color, 3\\n )\",\n \"def draw(self):\\r\\n if not self.stopped:\\r\\n super().draw()\\r\\n self.next_frame()\",\n \"def draw(self):\\n return ImageDraw.Draw(self.buffer)\",\n \"def Draw(self):\\n print ( 10*\\\"*\\\")\\n print (\\\"Player \\\" + self.character + \\\" says:\\\")\\n print (\\\"It's a Draw\\\")\\n print ( 10*\\\"*\\\")\",\n \"def draw(self):\\n\\n surf = self.get_oxygen_surface()\\n surf.set_alpha(255)\\n self.screen.blit(surf, self.pos)\",\n \"def on_draw(self):\\n # draw everything\",\n \"def draw(self, win):\\n self.rect.draw(win)\\n self.text.draw(win)\",\n \"def draw(self, surface, offset=(0,0)):\\n mouse = pg.mouse.get_pos()\\n pos = mouse[0]-offset[0], mouse[1]-offset[1]\\n if self.clicked:\\n fill_color = pg.Color(\\\"white\\\")\\n text = self.selected_text\\n elif self.rect.collidepoint(pos):\\n fill_color = (198, 226, 255)\\n text = self.selected_text\\n else:\\n fill_color = self.color\\n text = self.text\\n surface.fill(pg.Color(\\\"black\\\"), self.rect)\\n surface.fill(fill_color, self.rect.inflate(-2,-2))\\n surface.blit(text, self.text_rect)\",\n \"def draw(self, offset: IntegerPosition2D, canvas: Canvas) -> None:\\n canvas_position: IntegerPosition2D\\n if not self.buffer:\\n canvas_position = IntegerPosition2D(0, 0)\\n else:\\n row: int = self.buffer.get_row(self.index)\\n column: int = self.buffer.get_column(self.index)\\n canvas_position = IntegerPosition2D(column, row)\\n canvas_position += offset\\n\\n if not 0 <= canvas_position.x < canvas.size.width:\\n return\\n\\n if not 0 <= canvas_position.y < canvas.size.height:\\n return\\n\\n canvas.invert(canvas_position)\",\n \"def _blit(self):\\n libtcod.console_blit(self.console, 0, 0, self.width,\\n self.height, 0, 0, 0)\",\n \"def _draw(self):\\n\\n pygame.draw.circle(self.display, self.colour,\\n self.pos.astype(int),\\n self.rad)\\n pygame.draw.circle(self.display, black,\\n self.pos.astype(int),\\n self.rad, 2)\",\n \"def draw(self, *args, **kwargs) -> np.ndarray:\\n pass\",\n \"def draw(self, shape):\\n shape.draw(shader=self.shader)\",\n \"def draw(self):\\n self.ball_sprite.draw()\",\n \"def on_draw(self):\\n\\t\\tself.render()\",\n \"def on_draw(self):\\n\\t\\tself.render()\",\n \"def draw(self):\\n self.screen.blit(self.image, self.rect)\",\n \"def draw(self, p):\\r\\n self.active = True\\r\\n surface = pygame.surfarray.make_surface(p)\\r\\n self.screen.blit(surface, (0, 0))\\r\\n pygame.display.flip()\\r\\n return\",\n \"def Draw(self):\\n\\t\\tGameImage.Draw(self, self.coords)\",\n \"def draw(self):\\n if self.is_clicked:\\n pg.draw.circle(self.window, self.color, (self.x, self.y), self.r, 0)\\n else:\\n pg.draw.circle(self.window, self.color, (self.x, self.y), self.r, 1)\",\n \"def draw():\\n screen.fill((0, 0, 0))\\n alien.draw()\",\n \"def draw(self, cr, width, height):\\n cr.set_source_rgb(0, 0, 0)\\n cr.rectangle(0, 0, width, height)\\n cr.fill()\",\n \"def draw(self):\\r\\n self.__screen.draw_asteroid(self, self.__x, self.__y)\",\n \"def draw(self):\\n\\n State.screen.draw()\",\n \"def draw(self):\\n if self.dirty or (self.image is None):\\n self._render()\\n self.screen.blit(self.image, self.rect)\",\n \"def draw(self):\\r\\n pygame.draw.rect(self.screen, self.background_color, self.bounds)\\r\\n line_window = self.lines[self.scroll_window_top:self.scroll_window_bottom]\\r\\n for idx,line in enumerate(line_window):\\r\\n text = self.font.render(line, True, self.foreground_color)\\r\\n x,y = self._get_x_y_from_pos(self.position[0], self.position[1]+idx)\\r\\n self.screen.blit(text,(x,y))\\r\\n \\r\\n if self.cursor_visible and self.scroll_window_bottom == len(self.lines):\\r\\n x,y = self._get_x_y_from_pos(len(line_window[-1]), len(line_window))\\r\\n cursor_rect = pygame.Rect(x,y,\\r\\n self.text_width,self.text_height)\\r\\n pygame.draw.rect(self.screen, self.foreground_color, cursor_rect)\",\n \"def draw(self):\\n if self.type == 'Circle':\\n pygame.draw.circle(self.screen, SIM_COLORS['blue'], \\n (int(self._params[0]), int(self._params[1])), \\n int(self._params[2]), \\n 0)\\n elif self.type == 'Line':\\n pygame.draw.line(self.screen, SIM_COLORS['blue'],\\n (int(self._params[0]), int(self._params[1])),\\n (int(self._params[2]), int(self._params[3])), 5)\\n elif self.type == 'Rect':\\n pygame.draw.rect(self.screen, SIM_COLORS['blue'],\\n (int(self._params[0]), int(self._params[1]),\\n int(self._params[2]), int(self._params[3])) )\",\n \"def draw(self):\\n self.screen.fill(WHITE)\\n self.color_invalid()\\n self.draw_selected()\\n self.shade_locked_cells()\\n self.draw_grid()\\n self.draw_buttons()\\n self.draw_numbers()\",\n \"def draw(self):\\n arcade.draw_rectangle_outline(self.position_x, self.position_y, self.radius, self.color)\",\n \"def draw(self, win):\\n font = pygame.font.SysFont(\\\"comicsans\\\", 40)\\n\\n gap = self.width / 9\\n x = self.col * gap\\n y = self.row * gap\\n\\n if self.temp != 0 and self.value == 0:\\n text = font.render(str(self.temp), 1, (128,128,128))\\n win.blit(text, (x+5, y+5))\\n elif not(self.value == 0):\\n text = font.render(str(self.value), 1, (0, 0, 0))\\n win.blit(text, (x + (gap/2 - text.get_width()/2), y + (gap/2 - text.get_height()/2)))\\n\\n if self.selected:\\n pygame.draw.rect(win, (255,0,0), (x,y, gap ,gap), 3)\",\n \"def draw(self):\\n if (libt.map_is_in_fov(self.handler.fov_map, self.x, self.y) or \\n self.handler.world.map[self.x][self.y].seen and self.visible_in_fog):\\n libt.console_set_default_foreground(self.handler.game_map, self.colour)\\n libt.console_put_char(self.handler.game_map, self.x, self.y, \\n self.char, libt.BKGND_NONE)\",\n \"def draw(self, thing):\\n thing.draw(self, Point([2,2]), flip=1)\\n\\n # configure the scroll region\\n bbox = Canvas.bbox(self.canvas, ALL)\\n self.canvas.configure(scrollregion=bbox)\",\n \"def draw(self):\\n wave_counter = self.game.myfont.render(f\\\"Poziom: {self.wave_counter}\\\", False, (255, 255, 255))\\n self.game.screen.blit(wave_counter, (5, 95))\",\n \"def draw(self):\\r\\n self.screen.blit(self.image, self.image.get_rect())\",\n \"def __draw(self, screen):\\n\\n pygame.draw.rect(screen, (200, 255, 200), (self.x, self.y, self.width, self.height))\",\n \"def draw(self):\\n # IMPLEMENT ME\\n \\\"\\\"\\\"\\n GRectangle(x=GAME_WIDTH/2,y=GAME_HEIGHT/2,\\n width=GAME_WIDTH,height=GAME_HEIGHT,\\n fillcolor=introcs.RGB(0,0,0)).draw(self.view)\\n if self.getState() == STATE_INACTIVE:\\n self.getText().draw(self.view)\\n if self.getState() == STATE_PAUSED:\\n self.getText().draw(self.view)\\n if not self.getWave() is None:\\n self.getWave().draw(self.view)\\n if self.getState() == STATE_COMPLETE:\\n self.getText().draw(self.view)\\n if self.getState() == STATE_PAUSED or self.getState() == STATE_ACTIVE or self.getState() == STATE_COMPLETE:\\n self.getText().draw(self.view)\\n\\n GRectangle(x=GAME_WIDTH/2,y=GAME_HEIGHT/2,\\n width=GAME_WIDTH,height=GAME_HEIGHT,\\n fillcolor=introcs.RGB(0,0,0)).draw(self.view)\\\"\\\"\\\"\\n if not self.getText() is None:\\n self.getText().draw(self.view)\\n if not self.getWave() is None:\\n self.getWave().draw(self.view)\",\n \"def draw(self, color, x, y) -> None:\\n y_pos = y * self.scale\\n x_pos = x * self.scale\\n pg.draw.rect(self.screen, color, [x_pos, y_pos, self.scale-self.offset, self.scale-self.offset])\",\n \"def draw(self, surface, force=False):\\n if self.redraw or force:\\n surface.blit(self.image, self.loc)\\n self.redraw = False\",\n \"def draw_self(self):\\n self.ball_sprite.draw()\",\n \"def draw(self):\\n if not self.pressed:\\n #draw info prompt in room\\n arcade.draw_rectangle_filled(self.center_x, self.center_y, 20, 20, arcade.color.ANTIQUE_BRASS)\\n arcade.draw_text(\\\"?\\\", self.center_x, self.center_y, arcade.color.BLACK, anchor_x=\\\"center\\\", anchor_y=\\\"center\\\")\\n else:\\n #draw info to top of screen when clicked\\n arcade.draw_text(self.text, 10, settings.HEIGHT - 10, arcade.color.BLACK, anchor_x=\\\"left\\\", anchor_y=\\\"top\\\")\",\n \"def draw_me(self):\\r\\n\\t\\tself.image.fill((100, 200, 100))\\r\\n\\t\\tif self.active: pg.draw.rect(self.image, (100, 100, 200), self.frame, 3) #if active => draw frame around selected entity width 3\\r\\n\\t\\tself.display_surface.blit(self.image, self.rect)\",\n \"def draw(screen):\\n MY.restart_button.draw(screen)\\n MY.display_text.draw(screen)\",\n \"def draw(self):\\n self.vertex_list.draw(pyglet.gl.GL_QUADS)\\n self.label.draw()\",\n \"def draw(self,renderer,dx,dy):\\n for i in self.itemType.find('display'):\\n if i.tag == 'rect':\\n colors = i.find('color').text[1:-1].split(',')\\n SDL_SetRenderDrawColor(renderer,int(colors[0]),int(colors[1]),int(colors[2]),int(colors[3]) if len(colors) > 3 else 255)\\n rect = SDL_Rect()\\n rect.x, rect.y = self.getPos()\\n rect.x, rect.y = rect.x+dx,rect.y+dy\\n rect.w, rect.h = self.getSize()\\n SDL_RenderFillRect(renderer,rect)\",\n \"def pre_draw(self):\",\n \"def draw(self, color = Color.GREEN):\\n self.image[self.x, self.y] = color\",\n \"def draw(self):\\n if len(self.__points) >= 2:\\n self._total_length = 0\\n for i in range(len(self.__points) - 1):\\n p1 = self.__points[i]\\n p2 = self.__points[i + 1]\\n coords = self.__line_segment(p1, p2)\\n if not coords is None:\\n pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,\\n [0, 1, 2, 1, 2, 3],\\n ('v2i', coords),\\n ('c4b', self.color * 4)\\n )\\n coords = self.__line_cap(p2)\\n pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,\\n [0, 1, 2, 0, 2, 3],\\n ('v2i', coords),\\n ('c4b', self.color * 4)\\n )\",\n \"def draw(self):\\n arcade.draw_circle_filled(self.position_x, self.position_y, self.radius,self.player_color)\",\n \"def _draw(self, canvas, options):\\n pass # must override in subclass\",\n \"def draw(self):\\n self.screen.blit(self.image, (self.x_pos1, self.y_pos))\\n self.screen.blit(self.image, (self.x_pos2, self.y_pos))\",\n \"def draw(self, surface):\\r\\n surface.blit(self.image, self.rect)\",\n \"def draw(self, win):\\n pygame.draw.rect(win, self.color, self.rect)\",\n \"def draw(self, surface):\\n surface.blit(self.image, self.rect)\",\n \"def draw(self, surface):\\n surface.blit(self.image, self.rect)\",\n \"def draw(self, surface):\\r\\n if self.visible:\\r\\n surface.blit(self.image, (self.x, self.y))\",\n \"def draw(self):\\n\\n self.state_stack.peek().draw(self.screen)\",\n \"def draw(self):\\n return self._myCanvas.draw()\",\n \"def on_draw(self, screen):\\n raise NotImplemented(\\\"on_draw method should be implemented.\\\")\",\n \"def draw(self, force=False):\\n self.display.draw(force)\",\n \"def draw( self ):\\n\\t\\t\\t\\n\\t\\ttransposition = lambda point: (point[0] + WINDOW_X, WINDOW_Y - point[1])\\n\\t\\t\\t \\n\\t\\tx, y = transposition( self.position.xy )\\n\\t\\tpygame.draw.circle(self.screen, self.color, ( int(x + 0.5), int(y + 0.5) ), self.r)\",\n \"def draw(self):\\n self.bufferX = (self.appWidth/2) - self.viewX\\n self.bufferY = (self.appHeight/2) - self.viewY\\n anwp.sl.engine.clear()\\n anwp.sl.engine.drawImage(0, 0, self.appWidth, self.appHeight, self.backgroundImage)\\n self.drawWarpLines()\\n \\n # render engine\\n anwp.sl.engine.render()\\n self.drawSystemInfo()\\n self.drawWarpGateInfo()\\n self.drawWarpTradeInfo()\",\n \"def draw(self):\\n self.screen.fill((0,51,102))\\n # get the new drawables\\n self.drawables = (self.game_model.get_background_drawables()\\n + self.game_model.get_plane_drawables()\\n + self.game_model.get_bullet_drawables()\\n + self.game_model.get_enemy_drawables())\\n for d in self.drawables:\\n rect = d.get_rect()\\n surf = d.get_surface()\\n surf.set_colorkey((255,255,255))\\n self.screen.blit(surf, rect)\",\n \"def draw_brick(self, x, y):\\n pygame.draw.rect(self.main_surface, self.color, (x, y, self.width, self.height), 0)\\n pygame.display.update()\",\n \"def draw(self, force = False):\\n\\t\\tpass\",\n \"def draw(self, renderer, *args, **kwargs):\\n self.update_positions(renderer)\",\n \"def render(self, game):\\n pygame.draw.rect(game.screen,\\n self.colour,\\n (int(self.x), int(self.y), self.a, self.b))\",\n \"def blit_buffer(self, buffer, x, y, width, height):\\n self._set_window(x, y, x + width - 1, y + height - 1)\\n self._write(None, buffer)\",\n \"def draw(self):\\n self.screen.fill(Color.BLACK)\\n self.screen.blit(self.red_block, self.apple)\\n [self.screen.blit(self.green_block, xy) for xy in self.snake]\\n self.screen.blit(self.white_bar, (0, 0))\\n self.draw_text(str(self.score), self.score_pos, size=32)\\n pygame.display.flip()\",\n \"def draw(self):\\n if context.click():\\n self.place()\",\n \"def on_draw(self, da, ctx):\\n self.referee.get_current_state().draw(ctx)\",\n \"def draw(self):\\r\\n self.scr.fill(SCREEN_COLOR)\\r\\n self.label.draw()\\r\\n pygame.display.flip()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82649606","0.7830266","0.76652217","0.76652217","0.76652217","0.76652217","0.7653738","0.75657344","0.74521","0.735082","0.735082","0.735082","0.7295304","0.72623223","0.7143406","0.7132452","0.71102107","0.70918834","0.7013929","0.6921154","0.69120276","0.6901776","0.68663025","0.6853119","0.68148774","0.6810872","0.68012434","0.67446184","0.67221916","0.67203236","0.6697941","0.66787827","0.667652","0.6675842","0.6675707","0.66753155","0.6673052","0.6652077","0.6644139","0.66428274","0.6641461","0.663276","0.66279036","0.6627212","0.6625689","0.6625689","0.6623433","0.6619162","0.6614436","0.6603277","0.6599224","0.659389","0.6593059","0.6581172","0.65742844","0.6570823","0.656685","0.6564151","0.6555881","0.6550262","0.6546539","0.65455794","0.6544784","0.654368","0.65384775","0.6538009","0.6534283","0.65283823","0.65169203","0.65126866","0.65065324","0.6506487","0.65045375","0.65021473","0.64999354","0.64987296","0.64968187","0.6491699","0.64904505","0.6488517","0.6484628","0.64813983","0.64771044","0.64771044","0.6476457","0.6467388","0.64661014","0.64586544","0.64578974","0.64544225","0.6452856","0.6449203","0.6445868","0.64343065","0.64157134","0.64060557","0.64021033","0.6400138","0.6393588","0.6392063","0.638424"],"string":"[\n \"0.82649606\",\n \"0.7830266\",\n \"0.76652217\",\n \"0.76652217\",\n \"0.76652217\",\n \"0.76652217\",\n \"0.7653738\",\n \"0.75657344\",\n \"0.74521\",\n \"0.735082\",\n \"0.735082\",\n \"0.735082\",\n \"0.7295304\",\n \"0.72623223\",\n \"0.7143406\",\n \"0.7132452\",\n \"0.71102107\",\n \"0.70918834\",\n \"0.7013929\",\n \"0.6921154\",\n \"0.69120276\",\n \"0.6901776\",\n \"0.68663025\",\n \"0.6853119\",\n \"0.68148774\",\n \"0.6810872\",\n \"0.68012434\",\n \"0.67446184\",\n \"0.67221916\",\n \"0.67203236\",\n \"0.6697941\",\n \"0.66787827\",\n \"0.667652\",\n \"0.6675842\",\n \"0.6675707\",\n \"0.66753155\",\n \"0.6673052\",\n \"0.6652077\",\n \"0.6644139\",\n \"0.66428274\",\n \"0.6641461\",\n \"0.663276\",\n \"0.66279036\",\n \"0.6627212\",\n \"0.6625689\",\n \"0.6625689\",\n \"0.6623433\",\n \"0.6619162\",\n \"0.6614436\",\n \"0.6603277\",\n \"0.6599224\",\n \"0.659389\",\n \"0.6593059\",\n \"0.6581172\",\n \"0.65742844\",\n \"0.6570823\",\n \"0.656685\",\n \"0.6564151\",\n \"0.6555881\",\n \"0.6550262\",\n \"0.6546539\",\n \"0.65455794\",\n \"0.6544784\",\n \"0.654368\",\n \"0.65384775\",\n \"0.6538009\",\n \"0.6534283\",\n \"0.65283823\",\n \"0.65169203\",\n \"0.65126866\",\n \"0.65065324\",\n \"0.6506487\",\n \"0.65045375\",\n \"0.65021473\",\n \"0.64999354\",\n \"0.64987296\",\n \"0.64968187\",\n \"0.6491699\",\n \"0.64904505\",\n \"0.6488517\",\n \"0.6484628\",\n \"0.64813983\",\n \"0.64771044\",\n \"0.64771044\",\n \"0.6476457\",\n \"0.6467388\",\n \"0.64661014\",\n \"0.64586544\",\n \"0.64578974\",\n \"0.64544225\",\n \"0.6452856\",\n \"0.6449203\",\n \"0.6445868\",\n \"0.64343065\",\n \"0.64157134\",\n \"0.64060557\",\n \"0.64021033\",\n \"0.6400138\",\n \"0.6393588\",\n \"0.6392063\",\n \"0.638424\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14885,"cells":{"query":{"kind":"string","value":"Throw double buffer into widget drawable"},"document":{"kind":"string","value":"def on_draw(self, widget, cr):\n #print \"starting to draw\"\n if self.double_buffer is not None:\n self.draw_tiles()\n cr.set_source_surface(self.double_buffer, 0.0, 0.0)\n cr.paint()\n else:\n print('Invalid double buffer')\n #print \"done drawing\"\n return False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def init_buffer(self):\n \n self.shape.buf = [pi3d.Buffer(self.shape, self.verts, self.texcoords, self.inds, self.norms)]\n self.shape.set_draw_details(self.shader, [self.spritesheet.img])","def draw(self):","def draw(self, screen):","def pre_draw(self):","def on_configure(self, widget, event, data=None):\n print \"reconfiguring\"\n # Destroy previous buffer\n if self.double_buffer is not None:\n self.double_buffer.finish()\n self.double_buffer = None\n\n # Create a new buffer\n self.double_buffer = cairo.ImageSurface(cairo.FORMAT_ARGB32,\n widget.get_allocated_width(),\n widget.get_allocated_height())\n self.height = widget.get_allocated_height()\n self.width = widget.get_allocated_width()\n\n # Initialize the buffer\n self.draw_tiles()\n print \"config done\"\n return False","def __init__(self, *args):\n _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))\n # save a ref so the other dc will not be deleted before self\n self.__dc = args[0] \n # also save a ref to the bitmap\n if len(args) > 1: self.__bmp = args[1]","def on_draw_overlay(self):","def __init__(self, *args, **kwargs):\n _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))","def Blit(*args, **kwargs):\n return _gdi_.DC_Blit(*args, **kwargs)","def on_draw_over_image(self):","def _draw_widget(self, *args) -> None:\n del args\n\n if self.canvas is None:\n return\n\n # TODO: allow user to set rotation/scale origin\n center = center_of_points_list(self.points)\n self.canvas.clear()\n\n with self.canvas:\n Color(*self.color)\n Scale(self.scale, origin=center)\n Rotate(angle=self.rotation, origin=center)\n KivyPoint(points=self.points,\n pointsize=self.pointsize)","def draw():","def draw(self):\n\t\tpass","def fig2buf(fig):\n # draw the renderer\n fig.canvas.draw()\n\n # Get the RGBA buffer from the figure\n w,h = fig.canvas.get_width_height()\n buf = np.fromstring ( fig.canvas.tostring_argb(), dtype=np.uint8 )\n buf.shape = (h, w, 4)\n \n # canvas.tostring_argb give pixmap in ARGB mode. Roll the ALPHA channel to have it in RGBA mode\n buf = np.roll(buf, 3, axis = 2 )\n buf = buf[0::1,0::1] #slice to make image 4x smaller and use only the R channel of RGBA\n buf = buf[0::1,0::1, 0:3] #slice to make image 4x smaller and use only the R channel of RGBA\n return buf","def draw(self):\n return ImageDraw.Draw(self.buffer)","def decorate(self):\n\n c = self.canvas\n c.rect(20, 20, 20, 20, fill=1) # bt lf\n c.rect(self.width - 40, 20, 20, 20, fill=1) # bt rt\n c.rect(20, self.height - 40, 20, 20, fill=1) # tp lf\n c.rect(self.width/2 - 10, 20, 20, 20, fill=1) # bt md\n c.rect(20, self.height/2 - 10, 20, 20, fill=1) # md lf\n c.rect(self.width - 40, self.height - 40, 20, 20, fill=1) # tp rt\n c.rect(self.width - 40, self.height/2 - 10, 20, 20, fill=1) # md rt","def draw(self, surface):\n surface.blit(self.image, (0,0))\n for widget in self.widgets:\n widget.draw(surface)","def draw(self) -> Any:","def buffer(\n self,\n distance,\n resolution=...,\n quadsegs=...,\n cap_style=...,\n join_style=...,\n mitre_limit=...,\n single_sided=...,\n ): # -> BaseGeometry:\n ...","def draw(self, x, y):\r\n for w in self.widgets:\r\n if w.visible:\r\n w.draw()\r\n self.pointer.position(x + self.p_dx, y + self.p_dy, 0.5)\r\n self.pointer.draw()","def draw(self):\n pass","def draw(self):\n pass","def draw(self):\n pass","def draw(self):\n pass","def draw( self, **kw ):\n pass","def update(): # (12)\n with canvas(device) as draw:\n for led_pos in range(0, len(color_buffer)):\n color = color_buffer[led_pos]\n\n ## If your LED strip's colors are are not in the expected\n ## order, uncomment the following lines and adjust the indexes\n ## in the line color = (rgb[0], rgb[1], rgb[2])\n # rgb = getrgb(color)\n # color = (rgb[0], rgb[1], rgb[2])\n # if len(rgb) == 4:\n # color += (rgb[3],) # Add in Alpha\n\n draw.point((led_pos, 0), fill=color)","def pre_render(self) -> None:\n self.buffer = Surface((self.render_width, self.render_height), SRCALPHA)\n self.buffer.fill(list(self.halo_texture.surfaces.values())[0].get_at((0, 0)))\n\n self.buffer.fill((0, 0, 0, 0), Rect(\n (self.render_width - self.halo_texture.get_width()) // 2,\n (self.render_height - self.halo_texture.get_height()) // 2,\n self.halo_texture.get_width(),\n self.halo_texture.get_height()\n ))","def draw_brick(self, x, y):\n pygame.draw.rect(self.main_surface, self.color, (x, y, self.width, self.height), 0)\n pygame.display.update()","def __init__(self, *args, **kwargs):\n _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))\n if len(args) > 1: self.__bmp = args[1]","def blit(self):\n raise NotImplementedError()","def draw(self):\n self.batch.draw()","def draw_sprite(self, buf, x, y, w, h):\n x2 = x + w - 1\n y2 = y + h - 1\n if self.is_off_grid(x, y, x2, y2):\n return\n self.set_window(x, y, x2, y2, buf)","def PaneCreateStippleBitmap():\r\n\r\n data = [0, 0, 0, 192, 192, 192, 192, 192, 192, 0, 0, 0]\r\n img = wx.EmptyImage(2, 2)\r\n counter = 0\r\n \r\n for ii in xrange(2):\r\n for jj in xrange(2):\r\n img.SetRGB(ii, jj, data[counter], data[counter+1], data[counter+2])\r\n counter = counter + 3\r\n \r\n return img.ConvertToBitmap()","def draw(self, *args, **kwargs):\n self.window.clear()\n self.batch.draw()","def __init__(self, font):\r\n self.shader = pi3d.Shader(\"uv_flat\")\r\n dummycam = pi3d.Camera.instance() # in case this is prior to one being created \r\n self.camera = pi3d.Camera(is_3d=False)\r\n self.widgets = []\r\n self.font = font\r\n self.font.blend = True\r\n self.focus = None\r\n for p in sys.path:\r\n icon_path = p + '/pi3d/util/icons/'\r\n if os.path.exists(icon_path):\r\n self.icon_path = icon_path\r\n break\r\n tex = pi3d.Texture(self.icon_path + \"pointer.png\", blend=True, mipmap=False)\r\n self.pointer = pi3d.Sprite(camera=self.camera, w=tex.ix, h=tex.iy, z=0.5)\r\n self.pointer.set_draw_details(self.shader, [tex])\r\n self.p_dx, self.p_dy = tex.ix/2.0, -tex.iy/2.0\r\n self.next_tm = time.time() + DT","def _make_buffer(self, width, height):\n fb_prop = p3d.FrameBufferProperties(p3d.FrameBufferProperties.get_default())\n fb_prop.set_multisamples(self._multisamples)\n fb_prop.set_srgb_color(self._srgb_color)\n\n self._buffer = self._engine.make_output(\n self._pipe, name=\"offscreen\", sort=0,\n fb_prop=p3d.FrameBufferProperties.get_default(),\n win_prop=p3d.WindowProperties(size=(width, height)),\n flags=p3d.GraphicsPipe.BFRefuseWindow)\n\n self._region = self._buffer.make_display_region()\n\n self._depth_tex = p3d.Texture()\n self._depth_tex.setFormat(p3d.Texture.FDepthComponent)\n self._buffer.addRenderTexture(\n self._depth_tex, p3d.GraphicsOutput.RTMCopyRam, p3d.GraphicsOutput.RTPDepth)\n\n self._color_tex = p3d.Texture()\n self._color_tex.setFormat(p3d.Texture.FRgba8)\n self._buffer.addRenderTexture(\n self._color_tex, p3d.GraphicsOutput.RTMCopyRam, p3d.GraphicsOutput.RTPColor)","def _BitmapFromBufferRGBA(*args, **kwargs):\n return _gdi_._BitmapFromBufferRGBA(*args, **kwargs)","def OnDrawGTKStyle(self, event):\r\n\r\n dc = wx.AutoBufferedPaintDC(self._pButton)\r\n dc.SetBackground(wx.Brush(self.GetBackgroundColour()))\r\n dc.Clear()\r\n \r\n self.OnDrawGTKExpander(dc)\r\n self.OnDrawGTKText(dc)","def paint(self):\r\n pass","def _BitmapFromBuffer(*args, **kwargs):\n return _gdi_._BitmapFromBuffer(*args, **kwargs)","def create_buffers(self):","def draw(self, screen, offsets: tuple):\r\n pass","def OnCustomRender(self, dc, item, rect):\r\n \r\n pass","def filter(self, drawable):\n pass","def get_drawables(self):\n return DrawableSurface(self.image, pygame.Rect((self.bpos_x, self.bpos_y), self.image.get_size()))","def draw(self):\n if self.open:\n self.xpos += (200-self.xpos) * 0.1\n else:\n self.xpos += (-self.xpos) * 0.1\n\n # get the display size\n dispw, disph = c_int(), c_int()\n SDL_GetRendererOutputSize(self.rend,dispw,disph)\n\n # don't waste resources drawing the pallet if it isn't onscreen\n if self.xpos > 5:\n #draw the background for the tile pallet\n SDL_SetRenderDrawColor(self.rend,0,0,0,200)\n rect = SDL_Rect()\n rect.x, rect.y, rect.w, rect.h = round(self.xpos-200),0,200,disph.value\n SDL_RenderFillRect(self.rend,rect)\n\n # draw edge line \n SDL_SetRenderDrawColor(self.rend,255,255,255,255)\n rect.x, rect.y, rect.w, rect.h = round(self.xpos-1),0,1,disph.value\n SDL_RenderFillRect(self.rend,rect)\n\n # draw tile previews\n for i in range(len(self.itemList.items)+1):\n # highlight selected tile\n if i-1 == self.selected:\n rect.x, rect.y, rect.w, rect.h = round(self.xpos-185),i*150+45-self.scroll,138,138\n SDL_SetRenderDrawColor(self.rend,255,255,255,100)\n SDL_RenderFillRect(self.rend,rect)\n # draw tile preview\n rect.x, rect.y, rect.w, rect.h = round(self.xpos-180),i*150+50-self.scroll,128,128\n if i >= 1:\n for x in self.itemList.items[i-1].find('display'):\n if x.tag == 'rect':\n colors = x.find('color').text[1:-1].split(',')\n SDL_SetRenderDrawColor(self.rend,int(colors[0]),int(colors[1]),int(colors[2]),int(colors[3]) if len(colors) > 3 else 255)\n SDL_RenderFillRect(self.rend,rect)\n #SDL_RenderCopy(self.rend,self.tileSet.getTex(i),None,rect)\n SDL_SetRenderDrawColor(self.rend,255,255,255,255)\n\n # draw the file name for the tile\n quickRenderText(self.rend,self.ft_Mono16,self.itemList.items[i-1].find('name').text.strip(),rect.x,rect.y+128)\n else:\n #SDL_RenderCopy(self.rend,self.tileSet.getTex(i),None,rect)\n SDL_SetRenderDrawColor(self.rend,255,255,255,255)\n\n # draw the file name for the tile\n quickRenderText(self.rend,self.ft_Mono16,\"Edit Only\",rect.x,rect.y+128)","def paint(self, draw, x, y, w, h):\n\t\tpass","def draw(self):\n with self:\n self.batch.draw()","def EndDraw(self):\r\n\r\n pass","def draw(self, *args, **kwargs) -> np.ndarray:\n pass","def draw(self):\n self.game.screen.blit(self.image, self.game.off(self.pos))","def _draw_handler(self, bpy_dummy_self, bpy_dummy_context):\r\n self._drawRays()","def clearBuffer(self):\r\n self.__buffer =[[Pixel() for i in range(self.__width)] for i in range(self.__height)]","def on_draw_over_backgroundimage(self):","def _prepare_draw(self, view=None):\n pass","def dual_bullet():\n text = pygame.font.SysFont('arial', 10).render(\"x2\", True, (0, 0, 0))\n image = pygame.Surface((20, 20))\n image.fill(colour.SILVER)\n image.blit(text, (9, 6))\n pygame.draw.rect(image, colour.RED, (2, 4, 2, 12))\n pygame.draw.rect(image, colour.RED, (6, 4, 2, 12))\n return image","def expose (self,widget,event):\n #Creating Cairo drawing context\n self.ctx = self.bin_window.cairo_create()\n #Setting context size to available size\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\n self.ctx.clip()\n self.ctx.translate(0.5,-0.5)\n #Obtaining available width and height\n self.available_width = event.area.width\n self.available_height = event.area.height\n #Drawing\n self.draw(self.ctx)\n return False","def _BitmapFromBufferAlpha(*args, **kwargs):\n return _gdi_._BitmapFromBufferAlpha(*args, **kwargs)","def postDraw(self, xform=None, bbox=None):\n\n self.modulateTexture.unbindTexture()\n self.clipTexture .unbindTexture()\n self.colourTexture .unbindTexture()\n self.cmapTexture .unbindTexture()","def draw(self,renderer,dx,dy):\n for i in self.itemType.find('display'):\n if i.tag == 'rect':\n colors = i.find('color').text[1:-1].split(',')\n SDL_SetRenderDrawColor(renderer,int(colors[0]),int(colors[1]),int(colors[2]),int(colors[3]) if len(colors) > 3 else 255)\n rect = SDL_Rect()\n rect.x, rect.y = self.getPos()\n rect.x, rect.y = rect.x+dx,rect.y+dy\n rect.w, rect.h = self.getSize()\n SDL_RenderFillRect(renderer,rect)","def expose (self,widget,event):\n #Creating Cairo drawing context\n self.ctx = self.bin_window.cairo_create()\n #Setting context size to available size\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\n self.ctx.clip()\n self.ctx.translate(20.5,-0.5)\n #Obtaining available width and height\n self.available_width = event.area.width\n self.available_height = event.area.height\n #Drawing\n self.draw(self.ctx)\n return False","def _save_buffer(self):\n img_data = renderer.fbuffer.read(mode='color', alpha=False)\n img = Image.fromarray(img_data)\n img.save(self._save_fname)\n self._save_flag = False","def CopyFromBufferRGBA(self, buffer):\n self.CopyFromBuffer(buffer, wx.BitmapBufferFormat_RGBA)","def draw_wire(self, source, target, bend_out=False, bend_in=False):","def draw_overlay(self):\n pass","def down(self):\r\n self.brush_on = True","def widget_image(w):\n copy = w.image.copy()\n # Blit extra images onto copy\n for img in map(lambda x: w._images[x], w._extra_images):\n if img._show:\n copy.blit(img.image, img.rect)\n # Blend transparent surface when fading and blit to screen.\n if w._fade is not None:\n transparent = pygame.surface.Surface(w.rect.size, SRCALPHA)\n transparent.fill((255,255,255, w._fade))\n copy.blit(transparent, (0,0), special_flags=BLEND_RGBA_MULT)\n return copy","def draw(self):\n raise NotImplementedError","def draw(self):\n raise NotImplementedError","def draw(self):\n raise NotImplementedError","def OnBitmapButton2StarButton(self, event):\r\n\t\tself._configtmp[\"userrating\"] = 2\r\n\t\tself.SetStars()","def blit_buffer(self, buffer, x, y, width, height):\n self._set_window(x, y, x + width - 1, y + height - 1)\n self._write(None, buffer)","def drawItemPixmap(self, QPainter, QRect, p_int, QPixmap): # real signature unknown; restored from __doc__\n pass","def on_draw(self):\n # draw everything","def handle_release(self, x, y):\n # append new line to list of lines\n self.lines.append( (self.first_point, (x, y)) )\n\n # clear mouse pressed flag and rubber band line coords\n self.pressed_flag = False\n self.first_point = None\n self.last_point = None\n\n # trigger canvas to redraw itself\n self.redraw()","def draw_blinking (self, ctx):\n\t\tctx.save()\n\t\tctx.set_operator(cairo.OPERATOR_ATOP)\n\t\tctx.rectangle(0, 0, self.width, self.height)\n\t\tctx.set_source_rgba(1, 1, 1, self.__blink_phase)\n\t\tctx.fill()\n\t\tctx.save()","def draw(self, surface):\n surface.blit(self.base, self.base_rect)\n surface.blit(self.barrel, self.rect)","def boutton(self,img1,x,y):\r\n self.button.append(self.creat_image(img1,x,y))","def draw(self):\n self.write_image()\n self.update()","def _onPaint(self, evt):\n if not self._isRealized:\n self.realize()\n if self._drawn < 2:\n self.draw(repaint = False)\n self._drawn += 1\n self.gui_repaint(drawDC=wx.PaintDC(self))","def __init__(self, *args, **kwargs):\n _gdi_.DCBrushChanger_swiginit(self,_gdi_.new_DCBrushChanger(*args, **kwargs))","def draw(self, thing):\n thing.draw(self, Point([2,2]), flip=1)\n\n # configure the scroll region\n bbox = Canvas.bbox(self.canvas, ALL)\n self.canvas.configure(scrollregion=bbox)","def cb_vi_buffer(data, item, window):\n return vi_buffer","def draw(self):\n ui.clear()\n ui.draw_board(self)\n ui.output_buffer()","def draw(self):\r\n if not self.stopped:\r\n super().draw()\r\n self.next_frame()","def button_release_cb(self, darea, event):\n self.oldx, self.oldy = event.x, event.y\n self.draw_pointer(self.cr, None, None)\n self.queue_draw()\n self.oldx, self.oldy = None, None\n self.emit('end-dnd')\n return True","def updateDraw(self):\r\n self.delConns()\r\n self.delTags()\r\n self.drawConns()\r\n self.drawTags()","def D2(self, *args):\n return _Adaptor3d.Adaptor3d_Surface_D2(self, *args)","def draw(self, surface):\r\n surface.blit(self.image, self.rect)","def __init__(self, lf, width= None, height= None, sensitivity=2):\n super().__init__(size=(width, height))\n \n # Adjustable dimensions of the canvas and mouse sensitivity\n self.width = width or lf.shape[-2]\n self.height = height or lf.shape[-3]\n self.dim = lf.ndim\n self.sensitivity = sensitivity\n self.display_image = IpyImage()\n out_width = width//2\n out_height = 3*height//(4)\n slider_height = height - out_height\n self.out = Output(layout={'border': '1px solid black', 'width': f'{out_width}px', 'height': f'{out_height}px'})\n \n # Prepare the lightfields to be rendered with the self.draw function()\n self.lf = self.convert_lf(lf)\n self.downsampled_lf = self.downsample_lf(self.lf)\n \n if self.dim == 6:\n self.u_min, self.u_max = 0, self.lf.shape[1]-1\n self.v_min, self.v_max = 0, self.lf.shape[2]-1\n self.z_min, self.z_max = 0, self.lf.shape[0]-1\n elif self.dim == 5:\n self.u_min, self.u_max = 0, self.lf.shape[0]-1\n self.v_min, self.v_max = 0, self.lf.shape[1]-1\n self.z_min, self.z_max = 0, 0\n elif self.dim == 4:\n self.u_min, self.u_max = 0, 0\n self.v_min, self.v_max = 0, 0\n self.z_min, self.z_max = 0, self.lf.shape[0]-1\n else:\n raise Exception(\"unexpected number of dimensions for lightfield\")\n \n self.slider = IntSlider(min=0, max=self.z_max, value=0, description= 'Z',\n layout={'width': '', 'height': f'{slider_height}px',\n 'flex-flow': 'column', 'align-self': 'left'})\n self.slider.observe(self.handle_zoom_change, names='value')\n\n self.dragging = False\n self.x_mouse = None\n self.y_mouse = None\n \n self.u_idx = self.u_max//2\n self.v_idx = self.v_max//2\n self.z_idx = 0\n \n #Initialize state\n self.draw()\n \n self.on_mouse_down(self.mouse_down_handler)\n self.on_mouse_move(self.mouse_move_handler)\n self.on_mouse_up(self.mouse_up_handler)\n self.on_mouse_out(self.mouse_out_handler)","def delayed_buffer_item(self, buffer_item, buffer_item_len, item):\n item_copy = copy.copy(item)\n if buffer_item is None:\n buffer_item = buffer_item_len * [item_copy]\n else:\n buffer_item.append(item_copy)\n item_cur = copy.copy(buffer_item.pop(0))\n\n return buffer_item, item_cur","def getPixelsBuffer(self):\n\t\treturn self.leds","def redraw(dis):\n dis.blit(Bg,(0,0))","def append_buffer(self, buffer):\n\n first_data_idx = self.data[0][-1] + 1 if self.__len__() > 0 else 0\n\n d0 = [first_data_idx + i for i, _ in enumerate(buffer.memory)] # indexes\n d1 = [b[0] for b in buffer.memory] # actions\n d2 = [b[1][0] for b in buffer.memory] # speeds\n d3 = [b[1][3] for b in buffer.memory] # images\n d4 = [b[3] or b[4] for b in buffer.memory] # eoes\n d5 = [b[2] for b in buffer.memory] # rewards\n d6 = [b[5] for b in buffer.memory] # infos\n d7 = [b[1][1] for b in buffer.memory] # gears\n d8 = [b[1][2] for b in buffer.memory] # rpms\n d9 = [b[3] for b in buffer.memory] # terminated\n d10 = [b[4] for b in buffer.memory] # truncated\n\n if self.__len__() > 0:\n self.data[0] += d0\n self.data[1] += d1\n self.data[2] += d2\n self.data[3] += d3\n self.data[4] += d4\n self.data[5] += d5\n self.data[6] += d6\n self.data[7] += d7\n self.data[8] += d8\n self.data[9] += d9\n self.data[10] += d10\n else:\n self.data.append(d0)\n self.data.append(d1)\n self.data.append(d2)\n self.data.append(d3)\n self.data.append(d4)\n self.data.append(d5)\n self.data.append(d6)\n self.data.append(d7)\n self.data.append(d8)\n self.data.append(d9)\n self.data.append(d10)\n\n to_trim = self.__len__() - self.memory_size\n if to_trim > 0:\n self.data[0] = self.data[0][to_trim:]\n self.data[1] = self.data[1][to_trim:]\n self.data[2] = self.data[2][to_trim:]\n self.data[3] = self.data[3][to_trim:]\n self.data[4] = self.data[4][to_trim:]\n self.data[5] = self.data[5][to_trim:]\n self.data[6] = self.data[6][to_trim:]\n self.data[7] = self.data[7][to_trim:]\n self.data[8] = self.data[8][to_trim:]\n self.data[9] = self.data[9][to_trim:]\n self.data[10] = self.data[10][to_trim:]\n\n return self","def setup_draw(self):\n pass","def draw_bullet(self):\r\n pygame.draw.rect(self.screen, self.color, self.rect)","def update(time):\n\n def _fade(widget):\n \"\"\"Fade widget.\"\"\"\n if widget._fade is not None:\n widget.image.set_alpha(widget._fade)\n if widget._fade_up:\n widget._fade += time / 3.\n else:\n widget._fade -= time / 4.\n if widget._fade <= 0:\n # Remove after fading\n widget.kill()\n # Reset widget to be added again\n widget._fade = None\n elif widget._fade >= 255:\n widget._fade = None\n widget.image.set_alpha(255)\n\n def draw_opengl(image, rect, alpha):\n texture_data = pygame.image.tostring(image, \"RGBA\")\n\n w,h = image.get_size()\n tex = glGenTextures(1)\n if alpha is None:\n alpha = 255.\n glColor(0,0,0, alpha/255.)\n glBindTexture(GL_TEXTURE_2D, tex)\n glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD)\n glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)\n glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)\n glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,\n GL_UNSIGNED_BYTE, texture_data)\n\n glPushMatrix()\n glTranslatef(rect.x, rect.y, 0)\n\n glEnable(GL_TEXTURE_2D)\n #glBindTexture(GL_TEXTURE_2D, tex)\n glBegin(GL_QUADS)\n glTexCoord2f(0, 0)\n glVertex2f(0, 0)\n glTexCoord2f(1, 0)\n glVertex2f(w, 0)\n glTexCoord2f(1, 1)\n glVertex2f(w, h)\n glTexCoord2f(0, 1)\n glVertex2f(0, h)\n glEnd()\n\n glPopMatrix()\n\n glDeleteTextures(tex)\n\n def widget_image(w):\n \"\"\"Blit extra images, handle transparency fades and blit to screen.\"\"\"\n copy = w.image.copy()\n # Blit extra images onto copy\n for img in map(lambda x: w._images[x], w._extra_images):\n if img._show:\n copy.blit(img.image, img.rect)\n # Blend transparent surface when fading and blit to screen.\n if w._fade is not None:\n transparent = pygame.surface.Surface(w.rect.size, SRCALPHA)\n transparent.fill((255,255,255, w._fade))\n copy.blit(transparent, (0,0), special_flags=BLEND_RGBA_MULT)\n return copy\n\n if SCREEN._opengl:\n glMatrixMode(GL_PROJECTION)\n glLoadIdentity()\n w,h = SCREEN.get_size()\n glOrtho(0, w, h, 0, 0, 1)\n glMatrixMode(GL_MODELVIEW)\n glPushMatrix()\n glLoadIdentity()\n glDisable(GL_LIGHTING)\n glDisable(GL_DEPTH_TEST)\n glEnable(GL_SCISSOR_TEST)\n glEnable(GL_BLEND)\n glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)\n\n # Update widgets\n active_widgets.update(time)\n for widget in active_widgets:\n _fade(widget)\n for w in active_widgets:\n copy = widget_image(w)\n if not SCREEN._opengl:\n SCREEN.blit(copy, w.rect)\n else:\n draw_opengl(copy, w.rect, w._fade)\n\n # Update layered widgets\n layer_widgets.update(time)\n for widget in layer_widgets:\n _fade(widget)\n for w in layer_widgets:\n copy = widget_image(w)\n if not SCREEN._opengl:\n SCREEN.blit(copy, w.rect)\n else:\n draw_opengl(copy, w.rect, w._fade)\n\n if SCREEN._opengl:\n glDisable(GL_SCISSOR_TEST)\n glPopMatrix()","def getPNGBuffer():\n buf, n = dislin.rbfpng(0)\n buf, n = dislin.rbfpng(n)\n return buf","def draw(self, frame):\n frame[OFS:OFS+self.image.shape[0], OFS:OFS+self.image.shape[1]] = self.image","def _adjust_buffer(cb):\n\n def wrapper(self, flags):\n cb(self, flags)\n if self._pos < self._buffer_top:\n self._buffer_top = self._pos\n self._buffer_bottom = self._buffer_top + self._height - 1\n elif self._pos > self._buffer_bottom:\n self._buffer_bottom = self._pos\n self._buffer_top = self._buffer_bottom - self._height + 1\n return wrapper"],"string":"[\n \"def init_buffer(self):\\n \\n self.shape.buf = [pi3d.Buffer(self.shape, self.verts, self.texcoords, self.inds, self.norms)]\\n self.shape.set_draw_details(self.shader, [self.spritesheet.img])\",\n \"def draw(self):\",\n \"def draw(self, screen):\",\n \"def pre_draw(self):\",\n \"def on_configure(self, widget, event, data=None):\\n print \\\"reconfiguring\\\"\\n # Destroy previous buffer\\n if self.double_buffer is not None:\\n self.double_buffer.finish()\\n self.double_buffer = None\\n\\n # Create a new buffer\\n self.double_buffer = cairo.ImageSurface(cairo.FORMAT_ARGB32,\\n widget.get_allocated_width(),\\n widget.get_allocated_height())\\n self.height = widget.get_allocated_height()\\n self.width = widget.get_allocated_width()\\n\\n # Initialize the buffer\\n self.draw_tiles()\\n print \\\"config done\\\"\\n return False\",\n \"def __init__(self, *args):\\n _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))\\n # save a ref so the other dc will not be deleted before self\\n self.__dc = args[0] \\n # also save a ref to the bitmap\\n if len(args) > 1: self.__bmp = args[1]\",\n \"def on_draw_overlay(self):\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))\",\n \"def Blit(*args, **kwargs):\\n return _gdi_.DC_Blit(*args, **kwargs)\",\n \"def on_draw_over_image(self):\",\n \"def _draw_widget(self, *args) -> None:\\n del args\\n\\n if self.canvas is None:\\n return\\n\\n # TODO: allow user to set rotation/scale origin\\n center = center_of_points_list(self.points)\\n self.canvas.clear()\\n\\n with self.canvas:\\n Color(*self.color)\\n Scale(self.scale, origin=center)\\n Rotate(angle=self.rotation, origin=center)\\n KivyPoint(points=self.points,\\n pointsize=self.pointsize)\",\n \"def draw():\",\n \"def draw(self):\\n\\t\\tpass\",\n \"def fig2buf(fig):\\n # draw the renderer\\n fig.canvas.draw()\\n\\n # Get the RGBA buffer from the figure\\n w,h = fig.canvas.get_width_height()\\n buf = np.fromstring ( fig.canvas.tostring_argb(), dtype=np.uint8 )\\n buf.shape = (h, w, 4)\\n \\n # canvas.tostring_argb give pixmap in ARGB mode. Roll the ALPHA channel to have it in RGBA mode\\n buf = np.roll(buf, 3, axis = 2 )\\n buf = buf[0::1,0::1] #slice to make image 4x smaller and use only the R channel of RGBA\\n buf = buf[0::1,0::1, 0:3] #slice to make image 4x smaller and use only the R channel of RGBA\\n return buf\",\n \"def draw(self):\\n return ImageDraw.Draw(self.buffer)\",\n \"def decorate(self):\\n\\n c = self.canvas\\n c.rect(20, 20, 20, 20, fill=1) # bt lf\\n c.rect(self.width - 40, 20, 20, 20, fill=1) # bt rt\\n c.rect(20, self.height - 40, 20, 20, fill=1) # tp lf\\n c.rect(self.width/2 - 10, 20, 20, 20, fill=1) # bt md\\n c.rect(20, self.height/2 - 10, 20, 20, fill=1) # md lf\\n c.rect(self.width - 40, self.height - 40, 20, 20, fill=1) # tp rt\\n c.rect(self.width - 40, self.height/2 - 10, 20, 20, fill=1) # md rt\",\n \"def draw(self, surface):\\n surface.blit(self.image, (0,0))\\n for widget in self.widgets:\\n widget.draw(surface)\",\n \"def draw(self) -> Any:\",\n \"def buffer(\\n self,\\n distance,\\n resolution=...,\\n quadsegs=...,\\n cap_style=...,\\n join_style=...,\\n mitre_limit=...,\\n single_sided=...,\\n ): # -> BaseGeometry:\\n ...\",\n \"def draw(self, x, y):\\r\\n for w in self.widgets:\\r\\n if w.visible:\\r\\n w.draw()\\r\\n self.pointer.position(x + self.p_dx, y + self.p_dy, 0.5)\\r\\n self.pointer.draw()\",\n \"def draw(self):\\n pass\",\n \"def draw(self):\\n pass\",\n \"def draw(self):\\n pass\",\n \"def draw(self):\\n pass\",\n \"def draw( self, **kw ):\\n pass\",\n \"def update(): # (12)\\n with canvas(device) as draw:\\n for led_pos in range(0, len(color_buffer)):\\n color = color_buffer[led_pos]\\n\\n ## If your LED strip's colors are are not in the expected\\n ## order, uncomment the following lines and adjust the indexes\\n ## in the line color = (rgb[0], rgb[1], rgb[2])\\n # rgb = getrgb(color)\\n # color = (rgb[0], rgb[1], rgb[2])\\n # if len(rgb) == 4:\\n # color += (rgb[3],) # Add in Alpha\\n\\n draw.point((led_pos, 0), fill=color)\",\n \"def pre_render(self) -> None:\\n self.buffer = Surface((self.render_width, self.render_height), SRCALPHA)\\n self.buffer.fill(list(self.halo_texture.surfaces.values())[0].get_at((0, 0)))\\n\\n self.buffer.fill((0, 0, 0, 0), Rect(\\n (self.render_width - self.halo_texture.get_width()) // 2,\\n (self.render_height - self.halo_texture.get_height()) // 2,\\n self.halo_texture.get_width(),\\n self.halo_texture.get_height()\\n ))\",\n \"def draw_brick(self, x, y):\\n pygame.draw.rect(self.main_surface, self.color, (x, y, self.width, self.height), 0)\\n pygame.display.update()\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))\\n if len(args) > 1: self.__bmp = args[1]\",\n \"def blit(self):\\n raise NotImplementedError()\",\n \"def draw(self):\\n self.batch.draw()\",\n \"def draw_sprite(self, buf, x, y, w, h):\\n x2 = x + w - 1\\n y2 = y + h - 1\\n if self.is_off_grid(x, y, x2, y2):\\n return\\n self.set_window(x, y, x2, y2, buf)\",\n \"def PaneCreateStippleBitmap():\\r\\n\\r\\n data = [0, 0, 0, 192, 192, 192, 192, 192, 192, 0, 0, 0]\\r\\n img = wx.EmptyImage(2, 2)\\r\\n counter = 0\\r\\n \\r\\n for ii in xrange(2):\\r\\n for jj in xrange(2):\\r\\n img.SetRGB(ii, jj, data[counter], data[counter+1], data[counter+2])\\r\\n counter = counter + 3\\r\\n \\r\\n return img.ConvertToBitmap()\",\n \"def draw(self, *args, **kwargs):\\n self.window.clear()\\n self.batch.draw()\",\n \"def __init__(self, font):\\r\\n self.shader = pi3d.Shader(\\\"uv_flat\\\")\\r\\n dummycam = pi3d.Camera.instance() # in case this is prior to one being created \\r\\n self.camera = pi3d.Camera(is_3d=False)\\r\\n self.widgets = []\\r\\n self.font = font\\r\\n self.font.blend = True\\r\\n self.focus = None\\r\\n for p in sys.path:\\r\\n icon_path = p + '/pi3d/util/icons/'\\r\\n if os.path.exists(icon_path):\\r\\n self.icon_path = icon_path\\r\\n break\\r\\n tex = pi3d.Texture(self.icon_path + \\\"pointer.png\\\", blend=True, mipmap=False)\\r\\n self.pointer = pi3d.Sprite(camera=self.camera, w=tex.ix, h=tex.iy, z=0.5)\\r\\n self.pointer.set_draw_details(self.shader, [tex])\\r\\n self.p_dx, self.p_dy = tex.ix/2.0, -tex.iy/2.0\\r\\n self.next_tm = time.time() + DT\",\n \"def _make_buffer(self, width, height):\\n fb_prop = p3d.FrameBufferProperties(p3d.FrameBufferProperties.get_default())\\n fb_prop.set_multisamples(self._multisamples)\\n fb_prop.set_srgb_color(self._srgb_color)\\n\\n self._buffer = self._engine.make_output(\\n self._pipe, name=\\\"offscreen\\\", sort=0,\\n fb_prop=p3d.FrameBufferProperties.get_default(),\\n win_prop=p3d.WindowProperties(size=(width, height)),\\n flags=p3d.GraphicsPipe.BFRefuseWindow)\\n\\n self._region = self._buffer.make_display_region()\\n\\n self._depth_tex = p3d.Texture()\\n self._depth_tex.setFormat(p3d.Texture.FDepthComponent)\\n self._buffer.addRenderTexture(\\n self._depth_tex, p3d.GraphicsOutput.RTMCopyRam, p3d.GraphicsOutput.RTPDepth)\\n\\n self._color_tex = p3d.Texture()\\n self._color_tex.setFormat(p3d.Texture.FRgba8)\\n self._buffer.addRenderTexture(\\n self._color_tex, p3d.GraphicsOutput.RTMCopyRam, p3d.GraphicsOutput.RTPColor)\",\n \"def _BitmapFromBufferRGBA(*args, **kwargs):\\n return _gdi_._BitmapFromBufferRGBA(*args, **kwargs)\",\n \"def OnDrawGTKStyle(self, event):\\r\\n\\r\\n dc = wx.AutoBufferedPaintDC(self._pButton)\\r\\n dc.SetBackground(wx.Brush(self.GetBackgroundColour()))\\r\\n dc.Clear()\\r\\n \\r\\n self.OnDrawGTKExpander(dc)\\r\\n self.OnDrawGTKText(dc)\",\n \"def paint(self):\\r\\n pass\",\n \"def _BitmapFromBuffer(*args, **kwargs):\\n return _gdi_._BitmapFromBuffer(*args, **kwargs)\",\n \"def create_buffers(self):\",\n \"def draw(self, screen, offsets: tuple):\\r\\n pass\",\n \"def OnCustomRender(self, dc, item, rect):\\r\\n \\r\\n pass\",\n \"def filter(self, drawable):\\n pass\",\n \"def get_drawables(self):\\n return DrawableSurface(self.image, pygame.Rect((self.bpos_x, self.bpos_y), self.image.get_size()))\",\n \"def draw(self):\\n if self.open:\\n self.xpos += (200-self.xpos) * 0.1\\n else:\\n self.xpos += (-self.xpos) * 0.1\\n\\n # get the display size\\n dispw, disph = c_int(), c_int()\\n SDL_GetRendererOutputSize(self.rend,dispw,disph)\\n\\n # don't waste resources drawing the pallet if it isn't onscreen\\n if self.xpos > 5:\\n #draw the background for the tile pallet\\n SDL_SetRenderDrawColor(self.rend,0,0,0,200)\\n rect = SDL_Rect()\\n rect.x, rect.y, rect.w, rect.h = round(self.xpos-200),0,200,disph.value\\n SDL_RenderFillRect(self.rend,rect)\\n\\n # draw edge line \\n SDL_SetRenderDrawColor(self.rend,255,255,255,255)\\n rect.x, rect.y, rect.w, rect.h = round(self.xpos-1),0,1,disph.value\\n SDL_RenderFillRect(self.rend,rect)\\n\\n # draw tile previews\\n for i in range(len(self.itemList.items)+1):\\n # highlight selected tile\\n if i-1 == self.selected:\\n rect.x, rect.y, rect.w, rect.h = round(self.xpos-185),i*150+45-self.scroll,138,138\\n SDL_SetRenderDrawColor(self.rend,255,255,255,100)\\n SDL_RenderFillRect(self.rend,rect)\\n # draw tile preview\\n rect.x, rect.y, rect.w, rect.h = round(self.xpos-180),i*150+50-self.scroll,128,128\\n if i >= 1:\\n for x in self.itemList.items[i-1].find('display'):\\n if x.tag == 'rect':\\n colors = x.find('color').text[1:-1].split(',')\\n SDL_SetRenderDrawColor(self.rend,int(colors[0]),int(colors[1]),int(colors[2]),int(colors[3]) if len(colors) > 3 else 255)\\n SDL_RenderFillRect(self.rend,rect)\\n #SDL_RenderCopy(self.rend,self.tileSet.getTex(i),None,rect)\\n SDL_SetRenderDrawColor(self.rend,255,255,255,255)\\n\\n # draw the file name for the tile\\n quickRenderText(self.rend,self.ft_Mono16,self.itemList.items[i-1].find('name').text.strip(),rect.x,rect.y+128)\\n else:\\n #SDL_RenderCopy(self.rend,self.tileSet.getTex(i),None,rect)\\n SDL_SetRenderDrawColor(self.rend,255,255,255,255)\\n\\n # draw the file name for the tile\\n quickRenderText(self.rend,self.ft_Mono16,\\\"Edit Only\\\",rect.x,rect.y+128)\",\n \"def paint(self, draw, x, y, w, h):\\n\\t\\tpass\",\n \"def draw(self):\\n with self:\\n self.batch.draw()\",\n \"def EndDraw(self):\\r\\n\\r\\n pass\",\n \"def draw(self, *args, **kwargs) -> np.ndarray:\\n pass\",\n \"def draw(self):\\n self.game.screen.blit(self.image, self.game.off(self.pos))\",\n \"def _draw_handler(self, bpy_dummy_self, bpy_dummy_context):\\r\\n self._drawRays()\",\n \"def clearBuffer(self):\\r\\n self.__buffer =[[Pixel() for i in range(self.__width)] for i in range(self.__height)]\",\n \"def on_draw_over_backgroundimage(self):\",\n \"def _prepare_draw(self, view=None):\\n pass\",\n \"def dual_bullet():\\n text = pygame.font.SysFont('arial', 10).render(\\\"x2\\\", True, (0, 0, 0))\\n image = pygame.Surface((20, 20))\\n image.fill(colour.SILVER)\\n image.blit(text, (9, 6))\\n pygame.draw.rect(image, colour.RED, (2, 4, 2, 12))\\n pygame.draw.rect(image, colour.RED, (6, 4, 2, 12))\\n return image\",\n \"def expose (self,widget,event):\\n #Creating Cairo drawing context\\n self.ctx = self.bin_window.cairo_create()\\n #Setting context size to available size\\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\\n self.ctx.clip()\\n self.ctx.translate(0.5,-0.5)\\n #Obtaining available width and height\\n self.available_width = event.area.width\\n self.available_height = event.area.height\\n #Drawing\\n self.draw(self.ctx)\\n return False\",\n \"def _BitmapFromBufferAlpha(*args, **kwargs):\\n return _gdi_._BitmapFromBufferAlpha(*args, **kwargs)\",\n \"def postDraw(self, xform=None, bbox=None):\\n\\n self.modulateTexture.unbindTexture()\\n self.clipTexture .unbindTexture()\\n self.colourTexture .unbindTexture()\\n self.cmapTexture .unbindTexture()\",\n \"def draw(self,renderer,dx,dy):\\n for i in self.itemType.find('display'):\\n if i.tag == 'rect':\\n colors = i.find('color').text[1:-1].split(',')\\n SDL_SetRenderDrawColor(renderer,int(colors[0]),int(colors[1]),int(colors[2]),int(colors[3]) if len(colors) > 3 else 255)\\n rect = SDL_Rect()\\n rect.x, rect.y = self.getPos()\\n rect.x, rect.y = rect.x+dx,rect.y+dy\\n rect.w, rect.h = self.getSize()\\n SDL_RenderFillRect(renderer,rect)\",\n \"def expose (self,widget,event):\\n #Creating Cairo drawing context\\n self.ctx = self.bin_window.cairo_create()\\n #Setting context size to available size\\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\\n self.ctx.clip()\\n self.ctx.translate(20.5,-0.5)\\n #Obtaining available width and height\\n self.available_width = event.area.width\\n self.available_height = event.area.height\\n #Drawing\\n self.draw(self.ctx)\\n return False\",\n \"def _save_buffer(self):\\n img_data = renderer.fbuffer.read(mode='color', alpha=False)\\n img = Image.fromarray(img_data)\\n img.save(self._save_fname)\\n self._save_flag = False\",\n \"def CopyFromBufferRGBA(self, buffer):\\n self.CopyFromBuffer(buffer, wx.BitmapBufferFormat_RGBA)\",\n \"def draw_wire(self, source, target, bend_out=False, bend_in=False):\",\n \"def draw_overlay(self):\\n pass\",\n \"def down(self):\\r\\n self.brush_on = True\",\n \"def widget_image(w):\\n copy = w.image.copy()\\n # Blit extra images onto copy\\n for img in map(lambda x: w._images[x], w._extra_images):\\n if img._show:\\n copy.blit(img.image, img.rect)\\n # Blend transparent surface when fading and blit to screen.\\n if w._fade is not None:\\n transparent = pygame.surface.Surface(w.rect.size, SRCALPHA)\\n transparent.fill((255,255,255, w._fade))\\n copy.blit(transparent, (0,0), special_flags=BLEND_RGBA_MULT)\\n return copy\",\n \"def draw(self):\\n raise NotImplementedError\",\n \"def draw(self):\\n raise NotImplementedError\",\n \"def draw(self):\\n raise NotImplementedError\",\n \"def OnBitmapButton2StarButton(self, event):\\r\\n\\t\\tself._configtmp[\\\"userrating\\\"] = 2\\r\\n\\t\\tself.SetStars()\",\n \"def blit_buffer(self, buffer, x, y, width, height):\\n self._set_window(x, y, x + width - 1, y + height - 1)\\n self._write(None, buffer)\",\n \"def drawItemPixmap(self, QPainter, QRect, p_int, QPixmap): # real signature unknown; restored from __doc__\\n pass\",\n \"def on_draw(self):\\n # draw everything\",\n \"def handle_release(self, x, y):\\n # append new line to list of lines\\n self.lines.append( (self.first_point, (x, y)) )\\n\\n # clear mouse pressed flag and rubber band line coords\\n self.pressed_flag = False\\n self.first_point = None\\n self.last_point = None\\n\\n # trigger canvas to redraw itself\\n self.redraw()\",\n \"def draw_blinking (self, ctx):\\n\\t\\tctx.save()\\n\\t\\tctx.set_operator(cairo.OPERATOR_ATOP)\\n\\t\\tctx.rectangle(0, 0, self.width, self.height)\\n\\t\\tctx.set_source_rgba(1, 1, 1, self.__blink_phase)\\n\\t\\tctx.fill()\\n\\t\\tctx.save()\",\n \"def draw(self, surface):\\n surface.blit(self.base, self.base_rect)\\n surface.blit(self.barrel, self.rect)\",\n \"def boutton(self,img1,x,y):\\r\\n self.button.append(self.creat_image(img1,x,y))\",\n \"def draw(self):\\n self.write_image()\\n self.update()\",\n \"def _onPaint(self, evt):\\n if not self._isRealized:\\n self.realize()\\n if self._drawn < 2:\\n self.draw(repaint = False)\\n self._drawn += 1\\n self.gui_repaint(drawDC=wx.PaintDC(self))\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.DCBrushChanger_swiginit(self,_gdi_.new_DCBrushChanger(*args, **kwargs))\",\n \"def draw(self, thing):\\n thing.draw(self, Point([2,2]), flip=1)\\n\\n # configure the scroll region\\n bbox = Canvas.bbox(self.canvas, ALL)\\n self.canvas.configure(scrollregion=bbox)\",\n \"def cb_vi_buffer(data, item, window):\\n return vi_buffer\",\n \"def draw(self):\\n ui.clear()\\n ui.draw_board(self)\\n ui.output_buffer()\",\n \"def draw(self):\\r\\n if not self.stopped:\\r\\n super().draw()\\r\\n self.next_frame()\",\n \"def button_release_cb(self, darea, event):\\n self.oldx, self.oldy = event.x, event.y\\n self.draw_pointer(self.cr, None, None)\\n self.queue_draw()\\n self.oldx, self.oldy = None, None\\n self.emit('end-dnd')\\n return True\",\n \"def updateDraw(self):\\r\\n self.delConns()\\r\\n self.delTags()\\r\\n self.drawConns()\\r\\n self.drawTags()\",\n \"def D2(self, *args):\\n return _Adaptor3d.Adaptor3d_Surface_D2(self, *args)\",\n \"def draw(self, surface):\\r\\n surface.blit(self.image, self.rect)\",\n \"def __init__(self, lf, width= None, height= None, sensitivity=2):\\n super().__init__(size=(width, height))\\n \\n # Adjustable dimensions of the canvas and mouse sensitivity\\n self.width = width or lf.shape[-2]\\n self.height = height or lf.shape[-3]\\n self.dim = lf.ndim\\n self.sensitivity = sensitivity\\n self.display_image = IpyImage()\\n out_width = width//2\\n out_height = 3*height//(4)\\n slider_height = height - out_height\\n self.out = Output(layout={'border': '1px solid black', 'width': f'{out_width}px', 'height': f'{out_height}px'})\\n \\n # Prepare the lightfields to be rendered with the self.draw function()\\n self.lf = self.convert_lf(lf)\\n self.downsampled_lf = self.downsample_lf(self.lf)\\n \\n if self.dim == 6:\\n self.u_min, self.u_max = 0, self.lf.shape[1]-1\\n self.v_min, self.v_max = 0, self.lf.shape[2]-1\\n self.z_min, self.z_max = 0, self.lf.shape[0]-1\\n elif self.dim == 5:\\n self.u_min, self.u_max = 0, self.lf.shape[0]-1\\n self.v_min, self.v_max = 0, self.lf.shape[1]-1\\n self.z_min, self.z_max = 0, 0\\n elif self.dim == 4:\\n self.u_min, self.u_max = 0, 0\\n self.v_min, self.v_max = 0, 0\\n self.z_min, self.z_max = 0, self.lf.shape[0]-1\\n else:\\n raise Exception(\\\"unexpected number of dimensions for lightfield\\\")\\n \\n self.slider = IntSlider(min=0, max=self.z_max, value=0, description= 'Z',\\n layout={'width': '', 'height': f'{slider_height}px',\\n 'flex-flow': 'column', 'align-self': 'left'})\\n self.slider.observe(self.handle_zoom_change, names='value')\\n\\n self.dragging = False\\n self.x_mouse = None\\n self.y_mouse = None\\n \\n self.u_idx = self.u_max//2\\n self.v_idx = self.v_max//2\\n self.z_idx = 0\\n \\n #Initialize state\\n self.draw()\\n \\n self.on_mouse_down(self.mouse_down_handler)\\n self.on_mouse_move(self.mouse_move_handler)\\n self.on_mouse_up(self.mouse_up_handler)\\n self.on_mouse_out(self.mouse_out_handler)\",\n \"def delayed_buffer_item(self, buffer_item, buffer_item_len, item):\\n item_copy = copy.copy(item)\\n if buffer_item is None:\\n buffer_item = buffer_item_len * [item_copy]\\n else:\\n buffer_item.append(item_copy)\\n item_cur = copy.copy(buffer_item.pop(0))\\n\\n return buffer_item, item_cur\",\n \"def getPixelsBuffer(self):\\n\\t\\treturn self.leds\",\n \"def redraw(dis):\\n dis.blit(Bg,(0,0))\",\n \"def append_buffer(self, buffer):\\n\\n first_data_idx = self.data[0][-1] + 1 if self.__len__() > 0 else 0\\n\\n d0 = [first_data_idx + i for i, _ in enumerate(buffer.memory)] # indexes\\n d1 = [b[0] for b in buffer.memory] # actions\\n d2 = [b[1][0] for b in buffer.memory] # speeds\\n d3 = [b[1][3] for b in buffer.memory] # images\\n d4 = [b[3] or b[4] for b in buffer.memory] # eoes\\n d5 = [b[2] for b in buffer.memory] # rewards\\n d6 = [b[5] for b in buffer.memory] # infos\\n d7 = [b[1][1] for b in buffer.memory] # gears\\n d8 = [b[1][2] for b in buffer.memory] # rpms\\n d9 = [b[3] for b in buffer.memory] # terminated\\n d10 = [b[4] for b in buffer.memory] # truncated\\n\\n if self.__len__() > 0:\\n self.data[0] += d0\\n self.data[1] += d1\\n self.data[2] += d2\\n self.data[3] += d3\\n self.data[4] += d4\\n self.data[5] += d5\\n self.data[6] += d6\\n self.data[7] += d7\\n self.data[8] += d8\\n self.data[9] += d9\\n self.data[10] += d10\\n else:\\n self.data.append(d0)\\n self.data.append(d1)\\n self.data.append(d2)\\n self.data.append(d3)\\n self.data.append(d4)\\n self.data.append(d5)\\n self.data.append(d6)\\n self.data.append(d7)\\n self.data.append(d8)\\n self.data.append(d9)\\n self.data.append(d10)\\n\\n to_trim = self.__len__() - self.memory_size\\n if to_trim > 0:\\n self.data[0] = self.data[0][to_trim:]\\n self.data[1] = self.data[1][to_trim:]\\n self.data[2] = self.data[2][to_trim:]\\n self.data[3] = self.data[3][to_trim:]\\n self.data[4] = self.data[4][to_trim:]\\n self.data[5] = self.data[5][to_trim:]\\n self.data[6] = self.data[6][to_trim:]\\n self.data[7] = self.data[7][to_trim:]\\n self.data[8] = self.data[8][to_trim:]\\n self.data[9] = self.data[9][to_trim:]\\n self.data[10] = self.data[10][to_trim:]\\n\\n return self\",\n \"def setup_draw(self):\\n pass\",\n \"def draw_bullet(self):\\r\\n pygame.draw.rect(self.screen, self.color, self.rect)\",\n \"def update(time):\\n\\n def _fade(widget):\\n \\\"\\\"\\\"Fade widget.\\\"\\\"\\\"\\n if widget._fade is not None:\\n widget.image.set_alpha(widget._fade)\\n if widget._fade_up:\\n widget._fade += time / 3.\\n else:\\n widget._fade -= time / 4.\\n if widget._fade <= 0:\\n # Remove after fading\\n widget.kill()\\n # Reset widget to be added again\\n widget._fade = None\\n elif widget._fade >= 255:\\n widget._fade = None\\n widget.image.set_alpha(255)\\n\\n def draw_opengl(image, rect, alpha):\\n texture_data = pygame.image.tostring(image, \\\"RGBA\\\")\\n\\n w,h = image.get_size()\\n tex = glGenTextures(1)\\n if alpha is None:\\n alpha = 255.\\n glColor(0,0,0, alpha/255.)\\n glBindTexture(GL_TEXTURE_2D, tex)\\n glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD)\\n glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)\\n glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)\\n glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,\\n GL_UNSIGNED_BYTE, texture_data)\\n\\n glPushMatrix()\\n glTranslatef(rect.x, rect.y, 0)\\n\\n glEnable(GL_TEXTURE_2D)\\n #glBindTexture(GL_TEXTURE_2D, tex)\\n glBegin(GL_QUADS)\\n glTexCoord2f(0, 0)\\n glVertex2f(0, 0)\\n glTexCoord2f(1, 0)\\n glVertex2f(w, 0)\\n glTexCoord2f(1, 1)\\n glVertex2f(w, h)\\n glTexCoord2f(0, 1)\\n glVertex2f(0, h)\\n glEnd()\\n\\n glPopMatrix()\\n\\n glDeleteTextures(tex)\\n\\n def widget_image(w):\\n \\\"\\\"\\\"Blit extra images, handle transparency fades and blit to screen.\\\"\\\"\\\"\\n copy = w.image.copy()\\n # Blit extra images onto copy\\n for img in map(lambda x: w._images[x], w._extra_images):\\n if img._show:\\n copy.blit(img.image, img.rect)\\n # Blend transparent surface when fading and blit to screen.\\n if w._fade is not None:\\n transparent = pygame.surface.Surface(w.rect.size, SRCALPHA)\\n transparent.fill((255,255,255, w._fade))\\n copy.blit(transparent, (0,0), special_flags=BLEND_RGBA_MULT)\\n return copy\\n\\n if SCREEN._opengl:\\n glMatrixMode(GL_PROJECTION)\\n glLoadIdentity()\\n w,h = SCREEN.get_size()\\n glOrtho(0, w, h, 0, 0, 1)\\n glMatrixMode(GL_MODELVIEW)\\n glPushMatrix()\\n glLoadIdentity()\\n glDisable(GL_LIGHTING)\\n glDisable(GL_DEPTH_TEST)\\n glEnable(GL_SCISSOR_TEST)\\n glEnable(GL_BLEND)\\n glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)\\n\\n # Update widgets\\n active_widgets.update(time)\\n for widget in active_widgets:\\n _fade(widget)\\n for w in active_widgets:\\n copy = widget_image(w)\\n if not SCREEN._opengl:\\n SCREEN.blit(copy, w.rect)\\n else:\\n draw_opengl(copy, w.rect, w._fade)\\n\\n # Update layered widgets\\n layer_widgets.update(time)\\n for widget in layer_widgets:\\n _fade(widget)\\n for w in layer_widgets:\\n copy = widget_image(w)\\n if not SCREEN._opengl:\\n SCREEN.blit(copy, w.rect)\\n else:\\n draw_opengl(copy, w.rect, w._fade)\\n\\n if SCREEN._opengl:\\n glDisable(GL_SCISSOR_TEST)\\n glPopMatrix()\",\n \"def getPNGBuffer():\\n buf, n = dislin.rbfpng(0)\\n buf, n = dislin.rbfpng(n)\\n return buf\",\n \"def draw(self, frame):\\n frame[OFS:OFS+self.image.shape[0], OFS:OFS+self.image.shape[1]] = self.image\",\n \"def _adjust_buffer(cb):\\n\\n def wrapper(self, flags):\\n cb(self, flags)\\n if self._pos < self._buffer_top:\\n self._buffer_top = self._pos\\n self._buffer_bottom = self._buffer_top + self._height - 1\\n elif self._pos > self._buffer_bottom:\\n self._buffer_bottom = self._pos\\n self._buffer_top = self._buffer_bottom - self._height + 1\\n return wrapper\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5492979","0.54373515","0.541417","0.5406553","0.53597254","0.5355659","0.5354216","0.5340868","0.53357756","0.5319597","0.52766144","0.5271925","0.5259718","0.5236922","0.52361697","0.5216407","0.5194417","0.5152858","0.51386267","0.51239336","0.51079524","0.51079524","0.51079524","0.51079524","0.51078683","0.51076776","0.51038384","0.509398","0.5088107","0.50674677","0.50625896","0.5061526","0.5058232","0.50479656","0.50415623","0.503119","0.502236","0.50186193","0.50158834","0.4997791","0.49966672","0.49831495","0.49802858","0.49647817","0.49643257","0.4950489","0.4949042","0.49477947","0.49290487","0.49283895","0.49179262","0.49092507","0.49081993","0.49023634","0.4897655","0.48970982","0.4896122","0.48929438","0.48907694","0.4889695","0.4876943","0.4875356","0.48575658","0.4853544","0.48522153","0.48501912","0.48448417","0.48418403","0.48418403","0.48418403","0.48354802","0.48260748","0.48212105","0.48167038","0.4801121","0.4799477","0.47976494","0.47902104","0.4786712","0.47820878","0.4778088","0.47742212","0.47696105","0.47587323","0.47577623","0.47477558","0.47467133","0.47461522","0.47448984","0.47422487","0.4737473","0.47368917","0.47342905","0.47278434","0.4723548","0.47182223","0.47148073","0.4714148","0.47065878","0.4706571"],"string":"[\n \"0.5492979\",\n \"0.54373515\",\n \"0.541417\",\n \"0.5406553\",\n \"0.53597254\",\n \"0.5355659\",\n \"0.5354216\",\n \"0.5340868\",\n \"0.53357756\",\n \"0.5319597\",\n \"0.52766144\",\n \"0.5271925\",\n \"0.5259718\",\n \"0.5236922\",\n \"0.52361697\",\n \"0.5216407\",\n \"0.5194417\",\n \"0.5152858\",\n \"0.51386267\",\n \"0.51239336\",\n \"0.51079524\",\n \"0.51079524\",\n \"0.51079524\",\n \"0.51079524\",\n \"0.51078683\",\n \"0.51076776\",\n \"0.51038384\",\n \"0.509398\",\n \"0.5088107\",\n \"0.50674677\",\n \"0.50625896\",\n \"0.5061526\",\n \"0.5058232\",\n \"0.50479656\",\n \"0.50415623\",\n \"0.503119\",\n \"0.502236\",\n \"0.50186193\",\n \"0.50158834\",\n \"0.4997791\",\n \"0.49966672\",\n \"0.49831495\",\n \"0.49802858\",\n \"0.49647817\",\n \"0.49643257\",\n \"0.4950489\",\n \"0.4949042\",\n \"0.49477947\",\n \"0.49290487\",\n \"0.49283895\",\n \"0.49179262\",\n \"0.49092507\",\n \"0.49081993\",\n \"0.49023634\",\n \"0.4897655\",\n \"0.48970982\",\n \"0.4896122\",\n \"0.48929438\",\n \"0.48907694\",\n \"0.4889695\",\n \"0.4876943\",\n \"0.4875356\",\n \"0.48575658\",\n \"0.4853544\",\n \"0.48522153\",\n \"0.48501912\",\n \"0.48448417\",\n \"0.48418403\",\n \"0.48418403\",\n \"0.48418403\",\n \"0.48354802\",\n \"0.48260748\",\n \"0.48212105\",\n \"0.48167038\",\n \"0.4801121\",\n \"0.4799477\",\n \"0.47976494\",\n \"0.47902104\",\n \"0.4786712\",\n \"0.47820878\",\n \"0.4778088\",\n \"0.47742212\",\n \"0.47696105\",\n \"0.47587323\",\n \"0.47577623\",\n \"0.47477558\",\n \"0.47467133\",\n \"0.47461522\",\n \"0.47448984\",\n \"0.47422487\",\n \"0.4737473\",\n \"0.47368917\",\n \"0.47342905\",\n \"0.47278434\",\n \"0.4723548\",\n \"0.47182223\",\n \"0.47148073\",\n \"0.4714148\",\n \"0.47065878\",\n \"0.4706571\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6775266"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14886,"cells":{"query":{"kind":"string","value":"Configure the double buffer based on size of the widget"},"document":{"kind":"string","value":"def on_configure(self, widget, event, data=None):\n print \"reconfiguring\"\n # Destroy previous buffer\n if self.double_buffer is not None:\n self.double_buffer.finish()\n self.double_buffer = None\n\n # Create a new buffer\n self.double_buffer = cairo.ImageSurface(cairo.FORMAT_ARGB32,\n widget.get_allocated_width(),\n widget.get_allocated_height())\n self.height = widget.get_allocated_height()\n self.width = widget.get_allocated_width()\n\n # Initialize the buffer\n self.draw_tiles()\n print \"config done\"\n return False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def setBufferSize(self, buffer_size):\n DPxSetDinBuffSize(buffer_size)","def _changed_size(self, **kw):\n\t\tself._clear_matrix()\n\t\t\n\t\tself._recalc_adjustments()\n\t\t\n\t\tif self.flags() & gtk.REALIZED:\n\t\t\tif kw.get('resize', True): self.queue_resize()\n\t\t\tif kw.get('draw', True): self.queue_draw()","def set_widget_size(self, widget_size):\n v = self.viewport\n v.projection.widget_rect = Rect(\n mins=[0, 0],\n maxes=[widget_size[0], widget_size[1]])\n v.view.widget_size = v.projection.widget_rect.sizes","def on_size(self, event):\n size = self.GetSize()\n self.SetSize(size)\n gauge_pos, gauge_size = self.get_gauge_dimensions()\n self.gauge.SetSize(gauge_size)\n event.Skip()\n self.Update()","def on_draw(self, widget, cr):\n #print \"starting to draw\"\n if self.double_buffer is not None:\n self.draw_tiles()\n cr.set_source_surface(self.double_buffer, 0.0, 0.0)\n cr.paint()\n else:\n print('Invalid double buffer')\n #print \"done drawing\"\n return False","def use_buffer(self, buffer_size):\n self.__buffer_size = buffer_size\n if self.__buffer is None:\n self.__buffer = []","def onSetToHalfSize(self, evt):\n\t\tself.halfResampleZ.Enable(1)\n\t\tif self.dataUnits:\n\t\t\tx, y, z = self.dataUnits[0].dataSource.getOriginalDimensions()\n\t\t\tzf = 1\n\t\t\t\n\t\t\tif self.halfResampleZ.GetValue():\n\t\t\t\tzf = 0.5\n\t\t\tself.currSize = int(0.5 * x), int(0.5 * y), int(zf * z)\n\t\tself.fourthResampleZ.Enable(0)\n\t\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\n\t\t\tobj.Enable(0)","def OnSize(self, event):\r\n size = self.GetClientSizeTuple()\r\n self.gList.SetSize(size)","def on_size(self, event):\n # Forces reconfiguration of the viewport, modelview and projection\n # matrices on the next paint event\n self.init = False","def on_size(self, event):\n # Forces reconfiguration of the viewport, modelview and projection\n # matrices on the next paint event\n self.init = False","def OnSize(self, event):\r\n \r\n self.UpdateHintWindowSize()\r\n event.Skip()","def cb_size(self, event):\n if not self.size_timer.IsRunning():\n self.size_timer.StartOnce(2000)\n event.Skip(True)","def update_display(self):\n self.lick_plot_0.setData(self.k+self.T,self.buffer[:,1]) \n self.lick_plot_1.setData(self.k+self.T,self.buffer[:,2]) \n self.breathing_plot.setData(self.k+self.T,self.buffer[:,0]) \n \n if self.settings.movie_on.value():\n self.camera_image.setImage(self.camera.read())\n if self.settings.save_movie.value():\n self.camera.write()\n \n #print(self.buffer_h5.size)","def double_height_on(self):\n self._set_print_mode(self.DOUBLE_HEIGHT_MASK)","def SetUniformBitmapSize(self, size):\r\n\r\n self._requested_bmp_size = wx.Size(*size)\r\n\r\n # if window is already initialized, recalculate the tab height\r\n if self._dummy_wnd:\r\n self.UpdateTabCtrlHeight()","def onSize(self, event): \n\t\tw, h = self.GetClientSizeTuple()\n\t\tself.tree.SetDimensions(0, 0, w, h)","def _configure_canvas(event):\n if self.internal_frame.winfo_reqwidth() != self.canvas.winfo_width():\n## print \"frame\",self.internal_frame.winfo_reqwidth()\n## print \"canvas\",self.canvas.winfo_width()\n # update the inner frame's width to fill the canvas\n## self.canvas.itemconfigure(interior_id, width=self.canvas.winfo_width())\n self.canvas.config(width=self.internal_frame.winfo_reqwidth())\n if self.internal_frame.winfo_reqheight() != self.canvas.winfo_height():\n # update the inner frame's width to fill the canvas\n## self.canvas.itemconfigure(interior_id, width=self.canvas.winfo_width())\n self.canvas.config(height=self.internal_frame.winfo_reqheight())","def configure_canvas(self):\r\n self.window.update_idletasks() # this updates window size\r\n\r\n border = 10\r\n self.canvas.config(\r\n width=self.window.winfo_reqwidth() + border,\r\n height=min(350, self.window.winfo_reqheight() + border,))\r\n self.canvas.configure(scrollregion=(\r\n 0, 0,\r\n self.window.winfo_reqwidth() + border,\r\n self.window.winfo_reqheight() + border))","def __reconfig__(self, event):\r\n x, y = event.width//2, event.height//2\r\n self.canvas.config(scrollregion=(-x, -y, x, y))","def set_point_size(self, point_size=0.0):\r\n for b in self.buf:\r\n b.unib[8] = point_size","def on_resize(self, *args):\n\n self.page_current.width = terminal.width # Give page new terminal width\n self.render_buffer = []\n\n self.render() # Re-render buffer","def onSetToFourthSize(self, evt):\n\t\tself.halfResampleZ.Enable(0)\n\t\tself.fourthResampleZ.Enable(1)\n\t\tif self.dataUnits:\n\t\t\tzf = 1\n\t\t\tx, y, z = self.dataUnits[0].dataSource.getOriginalDimensions()\n\t\t\t\n\t\t\tif self.fourthResampleZ.GetValue():\n\t\t\t\tzf = 0.25\n\t\t\tself.currSize = int(0.25 * x), int(0.25 * y), int(zf * z) \n\t\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\n\t\t\tobj.Enable(0)","def FloatingSize(self, size):\r\n \r\n self.floating_size = wx.Size(*size)\r\n return self","def __init__(self, size: int):\n self.size = size\n self.window = []","def OnSize(self, event):\r\n\r\n self.Layout()","def set_mode(self, size, buffered=True, *args, **kwargs):\n self.canvas = Canvas(size, buffered)\n env.set_env('canvas', self.canvas)\n self.frame = Window.getDocumentRoot()\n env.set_env('frame', self.frame)\n panel = SimplePanel(Widget=self.canvas)\n RootPanel().add(panel)\n self.panel = panel\n self.vpanel = None\n self.textbox = None\n self.textarea = None\n self.Textbox = Textbox\n self.Textarea = Textarea\n self.surface = self.canvas.surface\n self.surface._display = self\n self._surface_rect = self.surface.get_rect()\n if not self.canvas._bufferedimage:\n self.flip = lambda: None\n self.update = lambda *arg: None\n return self.surface","def on_canvas_resize(self, event) -> None:\r\n\r\n self.painter.adjust_to_canvas()\r\n self.painter.draw_board()","def __init__(self, buffer_size=3000):\n self.buffer = []\n self.buffer_size = buffer_size","def __init__(self, buffer_size=3000):\n self.buffer = []\n self.buffer_size = buffer_size","def _set_size(self):\n if self.width_key is not None:\n width = config.get(self.width_key)\n height = config.get(self.height_key)\n self.window.resize(width, height)","def OnSize(self, event):\r\n\r\n if self._blindMode or not self.CanSetTransparent():\r\n self.MakeVenetianBlinds()","def do_buffer_size(num: int):\n if num == '':\n print(len(cmd_parser.daq.data))\n else:\n try:\n # TODO support rest of args to buffer resize\n cmd_parser.daq.buffer_resize(int(num))\n except ValueError:\n print('invalid input, [num] must be of type <int>')","def _component_size_changed(self):\n self._size_changed()","def enable_buffering(self, size: int = 5) -> None:\n if size <= 1:\n raise ValueError(\"buffer size too small\")\n\n self.buffered = True\n self._next = partial(next, self._buffered_generator(size))","def __init__(self, mx=10):\n super().__init__()\n\n self.__width = 500\n self.__height = 10\n\n self.bar = np.zeros((self.__height,self.__width,3), dtype=np.uint8) \n self.mx = mx \n self.setSizePolicy(\n QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Ignored,\n QtWidgets.QSizePolicy.Ignored))\n self.update()","def __init__(self):\n super(GraphVisualizerPointDraw, self).__init__()\n\n self.setMinimumSize(QSize(13, 13))\n self.setMaximumSize(QSize(13, 13))","def init_buffer(self):\n \n self.shape.buf = [pi3d.Buffer(self.shape, self.verts, self.texcoords, self.inds, self.norms)]\n self.shape.set_draw_details(self.shader, [self.spritesheet.img])","def update_size(self, dt):\n if self.cursor_on_button:\n self.size = min(self.SIZE_MAX, self.size + self.SCALING_VEL * dt)\n else:\n self.size = max(self.SIZE_MIN, self.size - self.SCALING_VEL * dt)\n self.surface = pg.transform.scale(self.image, (round(self.size), round(self.size)))","def updateSize(self, *args):\n return None","def create_buffers(self):","def __init__(self, *args, **kwargs):\n _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))","def _configure_interior(event):\n # update the scrollbars to match the size of the inner frame\n size = (self.internal_frame.winfo_reqwidth(), self.internal_frame.winfo_reqheight())\n self.canvas.config(scrollregion=\"0 0 %s %s\" % size)\n if self.internal_frame.winfo_reqwidth() != self.canvas.winfo_width():\n # update the canvas's width to fit the inner frame\n self.canvas.config(width=self.internal_frame.winfo_reqwidth())\n if self.internal_frame.winfo_reqheight() != self.canvas.winfo_height():\n # update the canvas's width to fit the inner frame\n self.canvas.config(height=self.internal_frame.winfo_reqheight())","def setDescriptorSize(self, dsize): # real signature unknown; restored from __doc__\n pass","def on_scale (self):\n\t\tif self.has_started:\n\t\t\tself.init_buffers()\n\t\t\tself.redraw_foreground()\n\t\t\tself.redraw_background()\n\n\t\tif self.expand2 == _('Use a scrollbar'):\n\t\t\tself.width = int((self.icon_size * 2 * self.rows + ((self.border_size+self.shadow_size)*2)+15 ) + 24/self.scale)\n\t\t\tself.update_scrollbar()","def set_max_output_buffer(self, *args):\n return _TestA_swig.my_qpsk_demod_cb_sptr_set_max_output_buffer(self, *args)","def on_size(self, event):\r\n event.Skip()\r\n self.text_info.Label = conf.InfoText\r\n wx.CallAfter(lambda: self and\r\n (self.text_info.Wrap(self.mediactrl.Size.width),\r\n self.text_info.Parent.Layout()))","def Pane_Resized( self, new_sizes ):\r\n if(new_sizes[0] > 200 ):\r\n cb.xtotal = new_sizes[0]-100\r\n self.canvas_one.config(width = new_sizes[0])\r\n self.canvas_scale.config(width = new_sizes[0])\r\n else:\r\n cb.xtotal = 200-100\r\n self.canvas_one.config(width = 200)\r\n self.canvas_scale.config(width = 200)\r\n if (len(new_sizes) > 1 ):\r\n self.canvas_two.config(width=new_sizes[1])\r\n self.system.Draw()","def changeSize(self, value):\n self.layer.brush_size = value","def updateSize(self, *args):\n width = self.width.get()\n height = self.height.get()\n self.initialXScale.config(to=width)\n self.initialYScale.config(to=height)\n # error check that state is not outside bounds\n for ball, state in self.ballStates.items():\n if state[0] > width:\n state[0] = width\n if state[1] > height:\n state[1] = height","def _save_size(self):\n if self.width_key is not None:\n (width, height) = self.window.get_size()\n config.set(self.width_key, width)\n config.set(self.height_key, height)\n config.save()","def rescale(self, event: tkinter.Event) -> None:\n # the properties which are linked to the event of reconfiguration\n # contain all the new sizes of the panel :\n self.width, self.height = event.width - 4, event.height - 4\n # The subtraction of 4 pixels is here to compensate the width\n # of the 'highlight bordure' rolling the canvas)\n self.draw_board()","def update_dimensions(self):\n self.chunk = numpy.full((self.current_height, self.current_width), fill_value=Constants.VALUE_INITIALIZER,\n dtype=\"int16\")","def double_width_on(self):\n self._set_print_mode(self.DOUBLE_WIDTH_MASK)","def _update_dimensions(self):\n _, self.width = self.window.getmaxyx()\n self.spacing = self.width // self.total_columns","def __onResize(self, ev):\n ev.Skip()\n self.__calcCanvasSizes()","def __enter__(self):\n self.old_size = plt.rcParams[\"font.size\"]\n plt.rcParams[\"font.size\"] = self.size","def _grid_hint_size(self) -> int:","def createWidgets(self):\n # create top menus\n self.menu= Menu(self.master)\n self.master.config(menu=self.menu)\n self.file_menu = Menu(self.menu)\n self.menu.add_cascade(label=\"File\", menu=self.file_menu)\n self.file_menu.add_command(label=\"Quit\", command=self.quit)\n\n self.edit_menu = Menu(self.menu)\n self.edit_opts_menu = Menu(self.edit_menu)\n self.menu.add_cascade(label=\"Edit\", menu=self.edit_menu)\n self.edit_menu.add_cascade(label=\"Options\", menu=self.edit_opts_menu)\n self.edit_menu.add_command(label=\"Clear Terminal\", command=lambda: self.terminal.delete(1.0,END))\n\n # Options\n self.autoscroll_value = BooleanVar()\n self.edit_opts_menu.add_checkbutton(label=\"Autoscroll\", onvalue=True, offvalue=False, variable=self.autoscroll_value)\n\n\n #----------------------------------------\n # Create the Device entry\n\n self.device_value = StringVar()\n self.device_value.set(self.device)\n self.device_label = Label( self.master, text=\"Port:\" )\n self.device_label.grid(row=0, column = 0,sticky=E)\n self.device_menu = OptionMenu( self.master, self.device_value, *self.device_choices) \n self.device_menu.config(width=40)\n self.device_menu.grid(row=0, column = 1)\n\n #----------------------------------------\n # Create the Baud rate entry\n\n self.baudrate_value = IntVar()\n self.baudrate_value.set(self.baudrate) # loaded from default, args, or config\n self.baudrate_choices = [ 9600, 14400, 19200, 28800, 38400, 57600, 102400, 115200, 128000, 230400, 256000, 460800, 512000, 921600, 1843200, 2048000 ]\n self.baudrate_label = Label( self.master, text=\"Baud rate:\" )\n self.baudrate_label.grid(row=0, column = 2, sticky=E)\n self.baudrate_menu = OptionMenu( self.master, self.baudrate_value, *self.baudrate_choices)\n self.baudrate_menu.config(width=10)\n self.baudrate_menu.grid(row=0, column = 3)\n\n #----------------------------------------\n # Create the Log file entry\n\n self.log_value = StringVar()\n self.log_value.set(self.logfile)\n self.log_label = Label( self.master, text=\"Log file:\" )\n self.log_label.grid(row=1,column = 0, sticky=E)\n self.log_entry = Entry( self.master, width = 46, textvariable=self.log_value )\n self.log_entry.grid(row=1, column = 1)\n self.log_button = Button (self.master, text=\"Browse\", command=self.browseLogFile)\n self.log_button.grid(row=1, column = 2, sticky=W)\n\n #----------------------------------------\n # Create the connect/disconnect button\n\n self.connect_button = Button ( self.master, text=\"Connect\", command=self.connect,width=12)\n self.connect_button.grid(row=1,column=3)\n\n #----------------------------------------\n # Create the terminal window\n\n self.terminal = Text( self.master, width = 65, background='black', foreground='white' )\n self.terminal.grid(row=2, column = 0, columnspan=4, sticky=E+W)\n\n # scroll bar\n self.terminal_scroller = AutoScrollbar(self.master, command=self.terminal.yview)\n self.terminal_scroller.grid(row=2,column=4, sticky=N+S)\n self.terminal.config(yscrollcommand=self.terminal_scroller.set)\n self.terminal_scroller_lastpos = (0.0, 1.0)\n self.autoscroll_value.set(True)","def ev_windowsizechanged(self, event: WindowResized) -> None:","def plotConfig( self, **args):\n length = args.get('length', None)\n if length:\n if length > 0:\n# print 'length: ', length\n self._plotlength = int(float(length))\n self.reset()","def update_scrollbar(self):\n self.testCanvas.bind('<Configure>', self.on_configure)\n self.testFrame.bind('<Configure>', self.on_configure)","def on_size(self, *args):\n self.canvas.before.clear()\n if hasattr(self, 'warn'):\n color = (.8, 0, 0) if self.warn else (0, .5, 0)\n else:\n color = (0, .5, 0)\n with self.canvas.before:\n Color(*color, 0.25)\n Rectangle(pos=self.pos, size=self.size)","def _refresh_buffers(self) -> None:","def set_receive_buffer_size(self, size):\n try:\n self._libudev.udev_monitor_set_receive_buffer_size(self, size)\n except EnvironmentError:\n self._reraise_with_socket_path()","def set_canvas_size(self, width, height):\n self.canvas.config(width = int(width), height = int(height))","def calc_size(self):\r\n self.height = HEIGHT_STATUS","def OnSize(self, event):\n wx.CallAfter(self.DoSetViewport)\n event.Skip()","def plot_insertsize():","def set_2d_size(self, w=None, h=None, x=0, y=0):\r\n from pi3d.Display import Display\r\n if w == None:\r\n w = Display.INSTANCE.width\r\n if h == None:\r\n h = Display.INSTANCE.height\r\n self.unif[42:44] = [x, y]\r\n self.unif[45:48] = [w, h, Display.INSTANCE.height]","def resize(self, size):\n self.widget.resize(*size)","def configure_cb(self, darea, event):\n self.width, self.height = darea.window.get_size()\n self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, self.width,\n self.height)\n self.cr = cairo.Context(self.surface)\n self.draw(self.cr, self.width, self.height)\n\n return True","def __init__(self, hidden_size):\n self.hidden_size = hidden_size","def __init__(self, master, values, *args, height=13, min_height=7, **kwargs):\n super().__init__(\n master, values, *args, height=height, min_height=min_height, **kwargs\n )\n self.bind(\"<Double-Button-1>\", self.on_double_click)\n self.click_job = None","def _init_plot_buffer(self, configuration):\n if not isinstance(configuration, dict):\n configuration = { 'length': configuration }\n\n # initialize vao/vbo\n vao, vbo = util.VAO(), util.VBO()\n\n # put kernel function into vertex shader\n vertex_shader_kernel = open(SHADER_DIR+'/data.vert.glsl').read()\n if configuration['kernel'] is not None:\n vertex_shader_kernel = vertex_shader_kernel.replace(\n self.KERNEL_PLACEHOLDER,\n configuration['kernel'])\n\n shader = util.Shader(\n vertex=vertex_shader_kernel,\n geometry=open(SHADER_DIR+'/data.geom.glsl').read(),\n fragment=open(SHADER_DIR+'/data.frag.glsl').read(),\n link=True\n )\n norm = configuration.get('norm', float)\n buffer_configuration = {\n 'byte_count': configuration['length'] * 4,\n 'vertex_count': configuration['length']/2,\n 'point_base_color': configuration.get('point_base_color', [0,0,0.5,1]),\n 'point_size': configuration.get('point_size', norm(2.0/configuration['length'])),\n 'vao': vao,\n 'vbo': vbo,\n 'shader': shader\n }\n\n # uniforms\n shader.uniform('mat_plane', self._mat_plot)\n shader.uniform('geometry_color', buffer_configuration['point_base_color'])\n shader.uniform('dot_size', buffer_configuration['point_size'])\n\n # configure vbo\n with vbo.get(0):\n vertex_position = shader.attributeLocation('vertex_position')\n glBufferData(GL_ARRAY_BUFFER, buffer_configuration['byte_count'], None, GL_STATIC_DRAW)\n with vao:\n glVertexAttribPointer(vertex_position, 2, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(0)\n\n return buffer_configuration","def handleResize(self):\n pass","def OnSize(self,event):\r\n\t\t\r\n self.SetupView()\r\n event.Skip()","def OnScrollSlider(self,event):\n\n size = str(self.sizeSlider.GetValue())\n self.sizeTextCtrl.SetValue(size)","def widgets(self):\r\n # ---- create variables ----\r\n self.totalBytes = IntVar() # depends on image size\r\n self.usedBytes = IntVar() # how many of them are used\r\n self.textStatus = StringVar() # used per total bytes\r\n self.useEncryption = IntVar() # 0-plain 1-AES\r\n self.mode = IntVar() # 0-read 1-write\r\n self.textOpt = dict() # text last config\r\n self.keyOpt = dict() # key last config\r\n self.loaded = False # image loaded or not\r\n # ---- create widgets ----\r\n self.label = Label(self, textvariable=self.textStatus)\r\n self.about = Label(self, text=\"About\", fg=\"blue\")\r\n self.text = Text(self, width=30, height=5, fg=\"grey\")\r\n self.scrollbar = Scrollbar(self, orient=\"vertical\", command=self.text.yview)\r\n self.loadButton = Button(self, text=\"Load\", width=5, command=lambda: self.action(\"load\"))\r\n self.readRadio = Radiobutton(self, text=\"Read\", variable=self.mode, value=0, command=self.set_state)\r\n self.checkButton = Checkbutton(self, text=\"Use AES\", variable=self.useEncryption, onvalue=1, offvalue=0, command=self.set_state)\r\n self.startButton = Button(self, text=\"Start\", width=5, state=\"disabled\", command=lambda: self.action(\"start\"))\r\n self.writeRadio = Radiobutton(self, text=\"Write\", variable=self.mode, value=1, command=self.set_state)\r\n self.keyEntry = Entry(self, width=10, fg=\"grey\", show=\"*\")\r\n # ---- show widgets ----\r\n self.label.grid(row=0, column=0, columnspan=2, sticky=\"w\")\r\n self.about.grid(row=0, column=2, sticky=\"e\")\r\n self.text.grid(row=1, column=0, rowspan=3, columnspan=3)\r\n self.scrollbar.grid(row=1, column=3, rowspan=3, sticky=\"ns\")\r\n self.loadButton.grid(row=4, column=0, sticky=\"w\", pady=5)\r\n self.readRadio.grid(row=4, column=1)\r\n self.checkButton.grid(row=4, column=2, sticky=\"e\")\r\n self.startButton.grid(row=5, column=0, sticky=\"w\")\r\n self.writeRadio.grid(row=5, column=1)\r\n self.keyEntry.grid(row=5, column=2, sticky=\"e\")","def DoSetSize(self, x, y, width, height, sizeFlags=wx.SIZE_AUTO):\r\n \r\n parent_size = self.GetParent().GetClientSize()\r\n if x + width > parent_size.x:\r\n width = max(0, parent_size.x - x)\r\n if y + height > parent_size.y:\r\n height = max(0, parent_size.y - y)\r\n\r\n wx.PyControl.DoSetSize(self, x, y, width, height, sizeFlags)","def grow_editor(self):\n self.mixerScrollArea.hide()\n return\n sp_height = self.mixerScrollArea.h_pad.height() + 3\n height = self.mixer.SYNTH_HEIGHT + sp_height \n self.mixerScrollArea.setFixedHeight(height + 10)","def _initialize_buffers(self) -> None:","def set_min_output_buffer(self, *args):\n return _TestA_swig.my_qpsk_demod_cb_sptr_set_min_output_buffer(self, *args)","def expose (self,widget,event):\n #Creating Cairo drawing context\n self.ctx = self.bin_window.cairo_create()\n #Setting context size to available size\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\n self.ctx.clip()\n self.ctx.translate(0.5,-0.5)\n #Obtaining available width and height\n self.available_width = event.area.width\n self.available_height = event.area.height\n #Drawing\n self.draw(self.ctx)\n return False","def double_height_off(self):\n self._unset_print_mode(self.DOUBLE_HEIGHT_MASK)","def setBlurSize(this, size):\n\t\tthis._KERNEL = np.ones((size, size), np.float32) / (size**2)","def __init__(self, width = 40):\n self.width = width\n self.state = 0\n self.total = 0","def _set_and_fill_buffer(self):\n # Set the buffer size for the nodal solution steps data. Existing nodal\n # solution step data may be lost.\n required_buffer_size = self.settings[\"buffer_size\"].GetInt()\n if required_buffer_size < self.GetMinimumBufferSize():\n required_buffer_size = self.GetMinimumBufferSize()\n current_buffer_size = self.main_model_part.GetBufferSize()\n buffer_size = max(current_buffer_size, required_buffer_size)\n self.main_model_part.SetBufferSize(buffer_size)\n # Cycle the buffer. This sets all historical nodal solution step data to\n # the current value and initializes the time stepping in the process info.\n delta_time = self.main_model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME]\n time = self.main_model_part.ProcessInfo[KratosMultiphysics.TIME]\n step =-buffer_size\n time = time - delta_time * buffer_size\n self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.TIME, time)\n for i in range(0, buffer_size):\n step = step + 1\n time = time + delta_time\n self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.STEP, step)\n self.main_model_part.CloneTimeStep(time)","def update_step_size(self):\n self.setSingleStep(10 ** self.step_exponent)\n self.update_format_string()","def config_do_not_scale_image_to_fit(self):\n # establish scrollbars\n self.sbarv = tkinter.Scrollbar(self, orient=tkinter.VERTICAL)\n self.sbarh = tkinter.Scrollbar(self, orient=tkinter.HORIZONTAL)\n self.sbarv.config(command=self.yview)\n self.sbarh.config(command=self.xview)\n\n self.config(yscrollcommand=self.sbarv.set)\n self.config(xscrollcommand=self.sbarh.set)\n self.sbarv.grid(row=0, column=1, stick=tkinter.N+tkinter.S)\n self.sbarh.grid(row=1, column=0, sticky=tkinter.E+tkinter.W)","def StretchBlitPointSize(*args, **kwargs):\n return _gdi_.DC_StretchBlitPointSize(*args, **kwargs)","def set_size(self, size):\n self.dtSize = size","def expose (self,widget,event):\n #Creating Cairo drawing context\n self.ctx = self.bin_window.cairo_create()\n #Setting context size to available size\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\n self.ctx.clip()\n self.ctx.translate(20.5,-0.5)\n #Obtaining available width and height\n self.available_width = event.area.width\n self.available_height = event.area.height\n #Drawing\n self.draw(self.ctx)\n return False","def widget_size(self) -> int:\n return self._widget_size","def Resize(self):\n\n self.history_length = int( round( self.owner['time_span']/self.owner['sample_speed']))\n self.FreshStart()","def ensure_size(self, device, size):\n if size != self.size:\n self.size = size\n usage = wgpu.TextureUsage.RENDER_ATTACHMENT | wgpu.TextureUsage.COPY_SRC\n if self.format.startswith((\"rgb\", \"bgr\")):\n usage |= wgpu.TextureUsage.TEXTURE_BINDING\n self.texture = device.create_texture(\n size=size, usage=usage, dimension=\"2d\", format=self.format\n )\n self.texture_view = self.texture.create_view()","def buffer(\n self,\n distance,\n resolution=...,\n quadsegs=...,\n cap_style=...,\n join_style=...,\n mitre_limit=...,\n single_sided=...,\n ): # -> BaseGeometry:\n ...","def shrink_editor(self):\n self.mixerScrollArea.show()\n sp_height = self.mixerScrollArea.h_pad.height() + 3\n height = self.mixer.HEIGHT + sp_height\n self.mixerScrollArea.setFixedHeight(height)","def __exit__(self, type, value, traceback):\n plt.rcParams[\"font.size\"] = self.old_size","def set_max_size(self, width: int, height: int):\n self.tk_ref.maxsize(width=width, height=height)","def _make_buffer(self, width, height):\n fb_prop = p3d.FrameBufferProperties(p3d.FrameBufferProperties.get_default())\n fb_prop.set_multisamples(self._multisamples)\n fb_prop.set_srgb_color(self._srgb_color)\n\n self._buffer = self._engine.make_output(\n self._pipe, name=\"offscreen\", sort=0,\n fb_prop=p3d.FrameBufferProperties.get_default(),\n win_prop=p3d.WindowProperties(size=(width, height)),\n flags=p3d.GraphicsPipe.BFRefuseWindow)\n\n self._region = self._buffer.make_display_region()\n\n self._depth_tex = p3d.Texture()\n self._depth_tex.setFormat(p3d.Texture.FDepthComponent)\n self._buffer.addRenderTexture(\n self._depth_tex, p3d.GraphicsOutput.RTMCopyRam, p3d.GraphicsOutput.RTPDepth)\n\n self._color_tex = p3d.Texture()\n self._color_tex.setFormat(p3d.Texture.FRgba8)\n self._buffer.addRenderTexture(\n self._color_tex, p3d.GraphicsOutput.RTMCopyRam, p3d.GraphicsOutput.RTPColor)"],"string":"[\n \"def setBufferSize(self, buffer_size):\\n DPxSetDinBuffSize(buffer_size)\",\n \"def _changed_size(self, **kw):\\n\\t\\tself._clear_matrix()\\n\\t\\t\\n\\t\\tself._recalc_adjustments()\\n\\t\\t\\n\\t\\tif self.flags() & gtk.REALIZED:\\n\\t\\t\\tif kw.get('resize', True): self.queue_resize()\\n\\t\\t\\tif kw.get('draw', True): self.queue_draw()\",\n \"def set_widget_size(self, widget_size):\\n v = self.viewport\\n v.projection.widget_rect = Rect(\\n mins=[0, 0],\\n maxes=[widget_size[0], widget_size[1]])\\n v.view.widget_size = v.projection.widget_rect.sizes\",\n \"def on_size(self, event):\\n size = self.GetSize()\\n self.SetSize(size)\\n gauge_pos, gauge_size = self.get_gauge_dimensions()\\n self.gauge.SetSize(gauge_size)\\n event.Skip()\\n self.Update()\",\n \"def on_draw(self, widget, cr):\\n #print \\\"starting to draw\\\"\\n if self.double_buffer is not None:\\n self.draw_tiles()\\n cr.set_source_surface(self.double_buffer, 0.0, 0.0)\\n cr.paint()\\n else:\\n print('Invalid double buffer')\\n #print \\\"done drawing\\\"\\n return False\",\n \"def use_buffer(self, buffer_size):\\n self.__buffer_size = buffer_size\\n if self.__buffer is None:\\n self.__buffer = []\",\n \"def onSetToHalfSize(self, evt):\\n\\t\\tself.halfResampleZ.Enable(1)\\n\\t\\tif self.dataUnits:\\n\\t\\t\\tx, y, z = self.dataUnits[0].dataSource.getOriginalDimensions()\\n\\t\\t\\tzf = 1\\n\\t\\t\\t\\n\\t\\t\\tif self.halfResampleZ.GetValue():\\n\\t\\t\\t\\tzf = 0.5\\n\\t\\t\\tself.currSize = int(0.5 * x), int(0.5 * y), int(zf * z)\\n\\t\\tself.fourthResampleZ.Enable(0)\\n\\t\\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\\n\\t\\t\\tobj.Enable(0)\",\n \"def OnSize(self, event):\\r\\n size = self.GetClientSizeTuple()\\r\\n self.gList.SetSize(size)\",\n \"def on_size(self, event):\\n # Forces reconfiguration of the viewport, modelview and projection\\n # matrices on the next paint event\\n self.init = False\",\n \"def on_size(self, event):\\n # Forces reconfiguration of the viewport, modelview and projection\\n # matrices on the next paint event\\n self.init = False\",\n \"def OnSize(self, event):\\r\\n \\r\\n self.UpdateHintWindowSize()\\r\\n event.Skip()\",\n \"def cb_size(self, event):\\n if not self.size_timer.IsRunning():\\n self.size_timer.StartOnce(2000)\\n event.Skip(True)\",\n \"def update_display(self):\\n self.lick_plot_0.setData(self.k+self.T,self.buffer[:,1]) \\n self.lick_plot_1.setData(self.k+self.T,self.buffer[:,2]) \\n self.breathing_plot.setData(self.k+self.T,self.buffer[:,0]) \\n \\n if self.settings.movie_on.value():\\n self.camera_image.setImage(self.camera.read())\\n if self.settings.save_movie.value():\\n self.camera.write()\\n \\n #print(self.buffer_h5.size)\",\n \"def double_height_on(self):\\n self._set_print_mode(self.DOUBLE_HEIGHT_MASK)\",\n \"def SetUniformBitmapSize(self, size):\\r\\n\\r\\n self._requested_bmp_size = wx.Size(*size)\\r\\n\\r\\n # if window is already initialized, recalculate the tab height\\r\\n if self._dummy_wnd:\\r\\n self.UpdateTabCtrlHeight()\",\n \"def onSize(self, event): \\n\\t\\tw, h = self.GetClientSizeTuple()\\n\\t\\tself.tree.SetDimensions(0, 0, w, h)\",\n \"def _configure_canvas(event):\\n if self.internal_frame.winfo_reqwidth() != self.canvas.winfo_width():\\n## print \\\"frame\\\",self.internal_frame.winfo_reqwidth()\\n## print \\\"canvas\\\",self.canvas.winfo_width()\\n # update the inner frame's width to fill the canvas\\n## self.canvas.itemconfigure(interior_id, width=self.canvas.winfo_width())\\n self.canvas.config(width=self.internal_frame.winfo_reqwidth())\\n if self.internal_frame.winfo_reqheight() != self.canvas.winfo_height():\\n # update the inner frame's width to fill the canvas\\n## self.canvas.itemconfigure(interior_id, width=self.canvas.winfo_width())\\n self.canvas.config(height=self.internal_frame.winfo_reqheight())\",\n \"def configure_canvas(self):\\r\\n self.window.update_idletasks() # this updates window size\\r\\n\\r\\n border = 10\\r\\n self.canvas.config(\\r\\n width=self.window.winfo_reqwidth() + border,\\r\\n height=min(350, self.window.winfo_reqheight() + border,))\\r\\n self.canvas.configure(scrollregion=(\\r\\n 0, 0,\\r\\n self.window.winfo_reqwidth() + border,\\r\\n self.window.winfo_reqheight() + border))\",\n \"def __reconfig__(self, event):\\r\\n x, y = event.width//2, event.height//2\\r\\n self.canvas.config(scrollregion=(-x, -y, x, y))\",\n \"def set_point_size(self, point_size=0.0):\\r\\n for b in self.buf:\\r\\n b.unib[8] = point_size\",\n \"def on_resize(self, *args):\\n\\n self.page_current.width = terminal.width # Give page new terminal width\\n self.render_buffer = []\\n\\n self.render() # Re-render buffer\",\n \"def onSetToFourthSize(self, evt):\\n\\t\\tself.halfResampleZ.Enable(0)\\n\\t\\tself.fourthResampleZ.Enable(1)\\n\\t\\tif self.dataUnits:\\n\\t\\t\\tzf = 1\\n\\t\\t\\tx, y, z = self.dataUnits[0].dataSource.getOriginalDimensions()\\n\\t\\t\\t\\n\\t\\t\\tif self.fourthResampleZ.GetValue():\\n\\t\\t\\t\\tzf = 0.25\\n\\t\\t\\tself.currSize = int(0.25 * x), int(0.25 * y), int(zf * z) \\n\\t\\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\\n\\t\\t\\tobj.Enable(0)\",\n \"def FloatingSize(self, size):\\r\\n \\r\\n self.floating_size = wx.Size(*size)\\r\\n return self\",\n \"def __init__(self, size: int):\\n self.size = size\\n self.window = []\",\n \"def OnSize(self, event):\\r\\n\\r\\n self.Layout()\",\n \"def set_mode(self, size, buffered=True, *args, **kwargs):\\n self.canvas = Canvas(size, buffered)\\n env.set_env('canvas', self.canvas)\\n self.frame = Window.getDocumentRoot()\\n env.set_env('frame', self.frame)\\n panel = SimplePanel(Widget=self.canvas)\\n RootPanel().add(panel)\\n self.panel = panel\\n self.vpanel = None\\n self.textbox = None\\n self.textarea = None\\n self.Textbox = Textbox\\n self.Textarea = Textarea\\n self.surface = self.canvas.surface\\n self.surface._display = self\\n self._surface_rect = self.surface.get_rect()\\n if not self.canvas._bufferedimage:\\n self.flip = lambda: None\\n self.update = lambda *arg: None\\n return self.surface\",\n \"def on_canvas_resize(self, event) -> None:\\r\\n\\r\\n self.painter.adjust_to_canvas()\\r\\n self.painter.draw_board()\",\n \"def __init__(self, buffer_size=3000):\\n self.buffer = []\\n self.buffer_size = buffer_size\",\n \"def __init__(self, buffer_size=3000):\\n self.buffer = []\\n self.buffer_size = buffer_size\",\n \"def _set_size(self):\\n if self.width_key is not None:\\n width = config.get(self.width_key)\\n height = config.get(self.height_key)\\n self.window.resize(width, height)\",\n \"def OnSize(self, event):\\r\\n\\r\\n if self._blindMode or not self.CanSetTransparent():\\r\\n self.MakeVenetianBlinds()\",\n \"def do_buffer_size(num: int):\\n if num == '':\\n print(len(cmd_parser.daq.data))\\n else:\\n try:\\n # TODO support rest of args to buffer resize\\n cmd_parser.daq.buffer_resize(int(num))\\n except ValueError:\\n print('invalid input, [num] must be of type <int>')\",\n \"def _component_size_changed(self):\\n self._size_changed()\",\n \"def enable_buffering(self, size: int = 5) -> None:\\n if size <= 1:\\n raise ValueError(\\\"buffer size too small\\\")\\n\\n self.buffered = True\\n self._next = partial(next, self._buffered_generator(size))\",\n \"def __init__(self, mx=10):\\n super().__init__()\\n\\n self.__width = 500\\n self.__height = 10\\n\\n self.bar = np.zeros((self.__height,self.__width,3), dtype=np.uint8) \\n self.mx = mx \\n self.setSizePolicy(\\n QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Ignored,\\n QtWidgets.QSizePolicy.Ignored))\\n self.update()\",\n \"def __init__(self):\\n super(GraphVisualizerPointDraw, self).__init__()\\n\\n self.setMinimumSize(QSize(13, 13))\\n self.setMaximumSize(QSize(13, 13))\",\n \"def init_buffer(self):\\n \\n self.shape.buf = [pi3d.Buffer(self.shape, self.verts, self.texcoords, self.inds, self.norms)]\\n self.shape.set_draw_details(self.shader, [self.spritesheet.img])\",\n \"def update_size(self, dt):\\n if self.cursor_on_button:\\n self.size = min(self.SIZE_MAX, self.size + self.SCALING_VEL * dt)\\n else:\\n self.size = max(self.SIZE_MIN, self.size - self.SCALING_VEL * dt)\\n self.surface = pg.transform.scale(self.image, (round(self.size), round(self.size)))\",\n \"def updateSize(self, *args):\\n return None\",\n \"def create_buffers(self):\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))\",\n \"def _configure_interior(event):\\n # update the scrollbars to match the size of the inner frame\\n size = (self.internal_frame.winfo_reqwidth(), self.internal_frame.winfo_reqheight())\\n self.canvas.config(scrollregion=\\\"0 0 %s %s\\\" % size)\\n if self.internal_frame.winfo_reqwidth() != self.canvas.winfo_width():\\n # update the canvas's width to fit the inner frame\\n self.canvas.config(width=self.internal_frame.winfo_reqwidth())\\n if self.internal_frame.winfo_reqheight() != self.canvas.winfo_height():\\n # update the canvas's width to fit the inner frame\\n self.canvas.config(height=self.internal_frame.winfo_reqheight())\",\n \"def setDescriptorSize(self, dsize): # real signature unknown; restored from __doc__\\n pass\",\n \"def on_scale (self):\\n\\t\\tif self.has_started:\\n\\t\\t\\tself.init_buffers()\\n\\t\\t\\tself.redraw_foreground()\\n\\t\\t\\tself.redraw_background()\\n\\n\\t\\tif self.expand2 == _('Use a scrollbar'):\\n\\t\\t\\tself.width = int((self.icon_size * 2 * self.rows + ((self.border_size+self.shadow_size)*2)+15 ) + 24/self.scale)\\n\\t\\t\\tself.update_scrollbar()\",\n \"def set_max_output_buffer(self, *args):\\n return _TestA_swig.my_qpsk_demod_cb_sptr_set_max_output_buffer(self, *args)\",\n \"def on_size(self, event):\\r\\n event.Skip()\\r\\n self.text_info.Label = conf.InfoText\\r\\n wx.CallAfter(lambda: self and\\r\\n (self.text_info.Wrap(self.mediactrl.Size.width),\\r\\n self.text_info.Parent.Layout()))\",\n \"def Pane_Resized( self, new_sizes ):\\r\\n if(new_sizes[0] > 200 ):\\r\\n cb.xtotal = new_sizes[0]-100\\r\\n self.canvas_one.config(width = new_sizes[0])\\r\\n self.canvas_scale.config(width = new_sizes[0])\\r\\n else:\\r\\n cb.xtotal = 200-100\\r\\n self.canvas_one.config(width = 200)\\r\\n self.canvas_scale.config(width = 200)\\r\\n if (len(new_sizes) > 1 ):\\r\\n self.canvas_two.config(width=new_sizes[1])\\r\\n self.system.Draw()\",\n \"def changeSize(self, value):\\n self.layer.brush_size = value\",\n \"def updateSize(self, *args):\\n width = self.width.get()\\n height = self.height.get()\\n self.initialXScale.config(to=width)\\n self.initialYScale.config(to=height)\\n # error check that state is not outside bounds\\n for ball, state in self.ballStates.items():\\n if state[0] > width:\\n state[0] = width\\n if state[1] > height:\\n state[1] = height\",\n \"def _save_size(self):\\n if self.width_key is not None:\\n (width, height) = self.window.get_size()\\n config.set(self.width_key, width)\\n config.set(self.height_key, height)\\n config.save()\",\n \"def rescale(self, event: tkinter.Event) -> None:\\n # the properties which are linked to the event of reconfiguration\\n # contain all the new sizes of the panel :\\n self.width, self.height = event.width - 4, event.height - 4\\n # The subtraction of 4 pixels is here to compensate the width\\n # of the 'highlight bordure' rolling the canvas)\\n self.draw_board()\",\n \"def update_dimensions(self):\\n self.chunk = numpy.full((self.current_height, self.current_width), fill_value=Constants.VALUE_INITIALIZER,\\n dtype=\\\"int16\\\")\",\n \"def double_width_on(self):\\n self._set_print_mode(self.DOUBLE_WIDTH_MASK)\",\n \"def _update_dimensions(self):\\n _, self.width = self.window.getmaxyx()\\n self.spacing = self.width // self.total_columns\",\n \"def __onResize(self, ev):\\n ev.Skip()\\n self.__calcCanvasSizes()\",\n \"def __enter__(self):\\n self.old_size = plt.rcParams[\\\"font.size\\\"]\\n plt.rcParams[\\\"font.size\\\"] = self.size\",\n \"def _grid_hint_size(self) -> int:\",\n \"def createWidgets(self):\\n # create top menus\\n self.menu= Menu(self.master)\\n self.master.config(menu=self.menu)\\n self.file_menu = Menu(self.menu)\\n self.menu.add_cascade(label=\\\"File\\\", menu=self.file_menu)\\n self.file_menu.add_command(label=\\\"Quit\\\", command=self.quit)\\n\\n self.edit_menu = Menu(self.menu)\\n self.edit_opts_menu = Menu(self.edit_menu)\\n self.menu.add_cascade(label=\\\"Edit\\\", menu=self.edit_menu)\\n self.edit_menu.add_cascade(label=\\\"Options\\\", menu=self.edit_opts_menu)\\n self.edit_menu.add_command(label=\\\"Clear Terminal\\\", command=lambda: self.terminal.delete(1.0,END))\\n\\n # Options\\n self.autoscroll_value = BooleanVar()\\n self.edit_opts_menu.add_checkbutton(label=\\\"Autoscroll\\\", onvalue=True, offvalue=False, variable=self.autoscroll_value)\\n\\n\\n #----------------------------------------\\n # Create the Device entry\\n\\n self.device_value = StringVar()\\n self.device_value.set(self.device)\\n self.device_label = Label( self.master, text=\\\"Port:\\\" )\\n self.device_label.grid(row=0, column = 0,sticky=E)\\n self.device_menu = OptionMenu( self.master, self.device_value, *self.device_choices) \\n self.device_menu.config(width=40)\\n self.device_menu.grid(row=0, column = 1)\\n\\n #----------------------------------------\\n # Create the Baud rate entry\\n\\n self.baudrate_value = IntVar()\\n self.baudrate_value.set(self.baudrate) # loaded from default, args, or config\\n self.baudrate_choices = [ 9600, 14400, 19200, 28800, 38400, 57600, 102400, 115200, 128000, 230400, 256000, 460800, 512000, 921600, 1843200, 2048000 ]\\n self.baudrate_label = Label( self.master, text=\\\"Baud rate:\\\" )\\n self.baudrate_label.grid(row=0, column = 2, sticky=E)\\n self.baudrate_menu = OptionMenu( self.master, self.baudrate_value, *self.baudrate_choices)\\n self.baudrate_menu.config(width=10)\\n self.baudrate_menu.grid(row=0, column = 3)\\n\\n #----------------------------------------\\n # Create the Log file entry\\n\\n self.log_value = StringVar()\\n self.log_value.set(self.logfile)\\n self.log_label = Label( self.master, text=\\\"Log file:\\\" )\\n self.log_label.grid(row=1,column = 0, sticky=E)\\n self.log_entry = Entry( self.master, width = 46, textvariable=self.log_value )\\n self.log_entry.grid(row=1, column = 1)\\n self.log_button = Button (self.master, text=\\\"Browse\\\", command=self.browseLogFile)\\n self.log_button.grid(row=1, column = 2, sticky=W)\\n\\n #----------------------------------------\\n # Create the connect/disconnect button\\n\\n self.connect_button = Button ( self.master, text=\\\"Connect\\\", command=self.connect,width=12)\\n self.connect_button.grid(row=1,column=3)\\n\\n #----------------------------------------\\n # Create the terminal window\\n\\n self.terminal = Text( self.master, width = 65, background='black', foreground='white' )\\n self.terminal.grid(row=2, column = 0, columnspan=4, sticky=E+W)\\n\\n # scroll bar\\n self.terminal_scroller = AutoScrollbar(self.master, command=self.terminal.yview)\\n self.terminal_scroller.grid(row=2,column=4, sticky=N+S)\\n self.terminal.config(yscrollcommand=self.terminal_scroller.set)\\n self.terminal_scroller_lastpos = (0.0, 1.0)\\n self.autoscroll_value.set(True)\",\n \"def ev_windowsizechanged(self, event: WindowResized) -> None:\",\n \"def plotConfig( self, **args):\\n length = args.get('length', None)\\n if length:\\n if length > 0:\\n# print 'length: ', length\\n self._plotlength = int(float(length))\\n self.reset()\",\n \"def update_scrollbar(self):\\n self.testCanvas.bind('<Configure>', self.on_configure)\\n self.testFrame.bind('<Configure>', self.on_configure)\",\n \"def on_size(self, *args):\\n self.canvas.before.clear()\\n if hasattr(self, 'warn'):\\n color = (.8, 0, 0) if self.warn else (0, .5, 0)\\n else:\\n color = (0, .5, 0)\\n with self.canvas.before:\\n Color(*color, 0.25)\\n Rectangle(pos=self.pos, size=self.size)\",\n \"def _refresh_buffers(self) -> None:\",\n \"def set_receive_buffer_size(self, size):\\n try:\\n self._libudev.udev_monitor_set_receive_buffer_size(self, size)\\n except EnvironmentError:\\n self._reraise_with_socket_path()\",\n \"def set_canvas_size(self, width, height):\\n self.canvas.config(width = int(width), height = int(height))\",\n \"def calc_size(self):\\r\\n self.height = HEIGHT_STATUS\",\n \"def OnSize(self, event):\\n wx.CallAfter(self.DoSetViewport)\\n event.Skip()\",\n \"def plot_insertsize():\",\n \"def set_2d_size(self, w=None, h=None, x=0, y=0):\\r\\n from pi3d.Display import Display\\r\\n if w == None:\\r\\n w = Display.INSTANCE.width\\r\\n if h == None:\\r\\n h = Display.INSTANCE.height\\r\\n self.unif[42:44] = [x, y]\\r\\n self.unif[45:48] = [w, h, Display.INSTANCE.height]\",\n \"def resize(self, size):\\n self.widget.resize(*size)\",\n \"def configure_cb(self, darea, event):\\n self.width, self.height = darea.window.get_size()\\n self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, self.width,\\n self.height)\\n self.cr = cairo.Context(self.surface)\\n self.draw(self.cr, self.width, self.height)\\n\\n return True\",\n \"def __init__(self, hidden_size):\\n self.hidden_size = hidden_size\",\n \"def __init__(self, master, values, *args, height=13, min_height=7, **kwargs):\\n super().__init__(\\n master, values, *args, height=height, min_height=min_height, **kwargs\\n )\\n self.bind(\\\"<Double-Button-1>\\\", self.on_double_click)\\n self.click_job = None\",\n \"def _init_plot_buffer(self, configuration):\\n if not isinstance(configuration, dict):\\n configuration = { 'length': configuration }\\n\\n # initialize vao/vbo\\n vao, vbo = util.VAO(), util.VBO()\\n\\n # put kernel function into vertex shader\\n vertex_shader_kernel = open(SHADER_DIR+'/data.vert.glsl').read()\\n if configuration['kernel'] is not None:\\n vertex_shader_kernel = vertex_shader_kernel.replace(\\n self.KERNEL_PLACEHOLDER,\\n configuration['kernel'])\\n\\n shader = util.Shader(\\n vertex=vertex_shader_kernel,\\n geometry=open(SHADER_DIR+'/data.geom.glsl').read(),\\n fragment=open(SHADER_DIR+'/data.frag.glsl').read(),\\n link=True\\n )\\n norm = configuration.get('norm', float)\\n buffer_configuration = {\\n 'byte_count': configuration['length'] * 4,\\n 'vertex_count': configuration['length']/2,\\n 'point_base_color': configuration.get('point_base_color', [0,0,0.5,1]),\\n 'point_size': configuration.get('point_size', norm(2.0/configuration['length'])),\\n 'vao': vao,\\n 'vbo': vbo,\\n 'shader': shader\\n }\\n\\n # uniforms\\n shader.uniform('mat_plane', self._mat_plot)\\n shader.uniform('geometry_color', buffer_configuration['point_base_color'])\\n shader.uniform('dot_size', buffer_configuration['point_size'])\\n\\n # configure vbo\\n with vbo.get(0):\\n vertex_position = shader.attributeLocation('vertex_position')\\n glBufferData(GL_ARRAY_BUFFER, buffer_configuration['byte_count'], None, GL_STATIC_DRAW)\\n with vao:\\n glVertexAttribPointer(vertex_position, 2, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(0)\\n\\n return buffer_configuration\",\n \"def handleResize(self):\\n pass\",\n \"def OnSize(self,event):\\r\\n\\t\\t\\r\\n self.SetupView()\\r\\n event.Skip()\",\n \"def OnScrollSlider(self,event):\\n\\n size = str(self.sizeSlider.GetValue())\\n self.sizeTextCtrl.SetValue(size)\",\n \"def widgets(self):\\r\\n # ---- create variables ----\\r\\n self.totalBytes = IntVar() # depends on image size\\r\\n self.usedBytes = IntVar() # how many of them are used\\r\\n self.textStatus = StringVar() # used per total bytes\\r\\n self.useEncryption = IntVar() # 0-plain 1-AES\\r\\n self.mode = IntVar() # 0-read 1-write\\r\\n self.textOpt = dict() # text last config\\r\\n self.keyOpt = dict() # key last config\\r\\n self.loaded = False # image loaded or not\\r\\n # ---- create widgets ----\\r\\n self.label = Label(self, textvariable=self.textStatus)\\r\\n self.about = Label(self, text=\\\"About\\\", fg=\\\"blue\\\")\\r\\n self.text = Text(self, width=30, height=5, fg=\\\"grey\\\")\\r\\n self.scrollbar = Scrollbar(self, orient=\\\"vertical\\\", command=self.text.yview)\\r\\n self.loadButton = Button(self, text=\\\"Load\\\", width=5, command=lambda: self.action(\\\"load\\\"))\\r\\n self.readRadio = Radiobutton(self, text=\\\"Read\\\", variable=self.mode, value=0, command=self.set_state)\\r\\n self.checkButton = Checkbutton(self, text=\\\"Use AES\\\", variable=self.useEncryption, onvalue=1, offvalue=0, command=self.set_state)\\r\\n self.startButton = Button(self, text=\\\"Start\\\", width=5, state=\\\"disabled\\\", command=lambda: self.action(\\\"start\\\"))\\r\\n self.writeRadio = Radiobutton(self, text=\\\"Write\\\", variable=self.mode, value=1, command=self.set_state)\\r\\n self.keyEntry = Entry(self, width=10, fg=\\\"grey\\\", show=\\\"*\\\")\\r\\n # ---- show widgets ----\\r\\n self.label.grid(row=0, column=0, columnspan=2, sticky=\\\"w\\\")\\r\\n self.about.grid(row=0, column=2, sticky=\\\"e\\\")\\r\\n self.text.grid(row=1, column=0, rowspan=3, columnspan=3)\\r\\n self.scrollbar.grid(row=1, column=3, rowspan=3, sticky=\\\"ns\\\")\\r\\n self.loadButton.grid(row=4, column=0, sticky=\\\"w\\\", pady=5)\\r\\n self.readRadio.grid(row=4, column=1)\\r\\n self.checkButton.grid(row=4, column=2, sticky=\\\"e\\\")\\r\\n self.startButton.grid(row=5, column=0, sticky=\\\"w\\\")\\r\\n self.writeRadio.grid(row=5, column=1)\\r\\n self.keyEntry.grid(row=5, column=2, sticky=\\\"e\\\")\",\n \"def DoSetSize(self, x, y, width, height, sizeFlags=wx.SIZE_AUTO):\\r\\n \\r\\n parent_size = self.GetParent().GetClientSize()\\r\\n if x + width > parent_size.x:\\r\\n width = max(0, parent_size.x - x)\\r\\n if y + height > parent_size.y:\\r\\n height = max(0, parent_size.y - y)\\r\\n\\r\\n wx.PyControl.DoSetSize(self, x, y, width, height, sizeFlags)\",\n \"def grow_editor(self):\\n self.mixerScrollArea.hide()\\n return\\n sp_height = self.mixerScrollArea.h_pad.height() + 3\\n height = self.mixer.SYNTH_HEIGHT + sp_height \\n self.mixerScrollArea.setFixedHeight(height + 10)\",\n \"def _initialize_buffers(self) -> None:\",\n \"def set_min_output_buffer(self, *args):\\n return _TestA_swig.my_qpsk_demod_cb_sptr_set_min_output_buffer(self, *args)\",\n \"def expose (self,widget,event):\\n #Creating Cairo drawing context\\n self.ctx = self.bin_window.cairo_create()\\n #Setting context size to available size\\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\\n self.ctx.clip()\\n self.ctx.translate(0.5,-0.5)\\n #Obtaining available width and height\\n self.available_width = event.area.width\\n self.available_height = event.area.height\\n #Drawing\\n self.draw(self.ctx)\\n return False\",\n \"def double_height_off(self):\\n self._unset_print_mode(self.DOUBLE_HEIGHT_MASK)\",\n \"def setBlurSize(this, size):\\n\\t\\tthis._KERNEL = np.ones((size, size), np.float32) / (size**2)\",\n \"def __init__(self, width = 40):\\n self.width = width\\n self.state = 0\\n self.total = 0\",\n \"def _set_and_fill_buffer(self):\\n # Set the buffer size for the nodal solution steps data. Existing nodal\\n # solution step data may be lost.\\n required_buffer_size = self.settings[\\\"buffer_size\\\"].GetInt()\\n if required_buffer_size < self.GetMinimumBufferSize():\\n required_buffer_size = self.GetMinimumBufferSize()\\n current_buffer_size = self.main_model_part.GetBufferSize()\\n buffer_size = max(current_buffer_size, required_buffer_size)\\n self.main_model_part.SetBufferSize(buffer_size)\\n # Cycle the buffer. This sets all historical nodal solution step data to\\n # the current value and initializes the time stepping in the process info.\\n delta_time = self.main_model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME]\\n time = self.main_model_part.ProcessInfo[KratosMultiphysics.TIME]\\n step =-buffer_size\\n time = time - delta_time * buffer_size\\n self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.TIME, time)\\n for i in range(0, buffer_size):\\n step = step + 1\\n time = time + delta_time\\n self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.STEP, step)\\n self.main_model_part.CloneTimeStep(time)\",\n \"def update_step_size(self):\\n self.setSingleStep(10 ** self.step_exponent)\\n self.update_format_string()\",\n \"def config_do_not_scale_image_to_fit(self):\\n # establish scrollbars\\n self.sbarv = tkinter.Scrollbar(self, orient=tkinter.VERTICAL)\\n self.sbarh = tkinter.Scrollbar(self, orient=tkinter.HORIZONTAL)\\n self.sbarv.config(command=self.yview)\\n self.sbarh.config(command=self.xview)\\n\\n self.config(yscrollcommand=self.sbarv.set)\\n self.config(xscrollcommand=self.sbarh.set)\\n self.sbarv.grid(row=0, column=1, stick=tkinter.N+tkinter.S)\\n self.sbarh.grid(row=1, column=0, sticky=tkinter.E+tkinter.W)\",\n \"def StretchBlitPointSize(*args, **kwargs):\\n return _gdi_.DC_StretchBlitPointSize(*args, **kwargs)\",\n \"def set_size(self, size):\\n self.dtSize = size\",\n \"def expose (self,widget,event):\\n #Creating Cairo drawing context\\n self.ctx = self.bin_window.cairo_create()\\n #Setting context size to available size\\n self.ctx.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)\\n self.ctx.clip()\\n self.ctx.translate(20.5,-0.5)\\n #Obtaining available width and height\\n self.available_width = event.area.width\\n self.available_height = event.area.height\\n #Drawing\\n self.draw(self.ctx)\\n return False\",\n \"def widget_size(self) -> int:\\n return self._widget_size\",\n \"def Resize(self):\\n\\n self.history_length = int( round( self.owner['time_span']/self.owner['sample_speed']))\\n self.FreshStart()\",\n \"def ensure_size(self, device, size):\\n if size != self.size:\\n self.size = size\\n usage = wgpu.TextureUsage.RENDER_ATTACHMENT | wgpu.TextureUsage.COPY_SRC\\n if self.format.startswith((\\\"rgb\\\", \\\"bgr\\\")):\\n usage |= wgpu.TextureUsage.TEXTURE_BINDING\\n self.texture = device.create_texture(\\n size=size, usage=usage, dimension=\\\"2d\\\", format=self.format\\n )\\n self.texture_view = self.texture.create_view()\",\n \"def buffer(\\n self,\\n distance,\\n resolution=...,\\n quadsegs=...,\\n cap_style=...,\\n join_style=...,\\n mitre_limit=...,\\n single_sided=...,\\n ): # -> BaseGeometry:\\n ...\",\n \"def shrink_editor(self):\\n self.mixerScrollArea.show()\\n sp_height = self.mixerScrollArea.h_pad.height() + 3\\n height = self.mixer.HEIGHT + sp_height\\n self.mixerScrollArea.setFixedHeight(height)\",\n \"def __exit__(self, type, value, traceback):\\n plt.rcParams[\\\"font.size\\\"] = self.old_size\",\n \"def set_max_size(self, width: int, height: int):\\n self.tk_ref.maxsize(width=width, height=height)\",\n \"def _make_buffer(self, width, height):\\n fb_prop = p3d.FrameBufferProperties(p3d.FrameBufferProperties.get_default())\\n fb_prop.set_multisamples(self._multisamples)\\n fb_prop.set_srgb_color(self._srgb_color)\\n\\n self._buffer = self._engine.make_output(\\n self._pipe, name=\\\"offscreen\\\", sort=0,\\n fb_prop=p3d.FrameBufferProperties.get_default(),\\n win_prop=p3d.WindowProperties(size=(width, height)),\\n flags=p3d.GraphicsPipe.BFRefuseWindow)\\n\\n self._region = self._buffer.make_display_region()\\n\\n self._depth_tex = p3d.Texture()\\n self._depth_tex.setFormat(p3d.Texture.FDepthComponent)\\n self._buffer.addRenderTexture(\\n self._depth_tex, p3d.GraphicsOutput.RTMCopyRam, p3d.GraphicsOutput.RTPDepth)\\n\\n self._color_tex = p3d.Texture()\\n self._color_tex.setFormat(p3d.Texture.FRgba8)\\n self._buffer.addRenderTexture(\\n self._color_tex, p3d.GraphicsOutput.RTMCopyRam, p3d.GraphicsOutput.RTPColor)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.610253","0.5766414","0.5608554","0.56082743","0.5588019","0.55230093","0.5471639","0.54091835","0.5401123","0.5401123","0.5352664","0.53298753","0.5326704","0.5319585","0.53189176","0.53112936","0.53038687","0.5290001","0.52694154","0.5253243","0.52476627","0.523922","0.52297443","0.5229701","0.518845","0.51817435","0.5160045","0.5155831","0.5155831","0.5151278","0.51422364","0.51406705","0.51399904","0.5137865","0.5116423","0.51093125","0.5108477","0.51031625","0.50941175","0.50769424","0.5057904","0.505595","0.505425","0.5043357","0.5036213","0.5026084","0.5015972","0.50066376","0.50049156","0.5004661","0.49843317","0.49755844","0.49689588","0.4967986","0.49528","0.4951237","0.49434888","0.49409115","0.49369526","0.4934715","0.49345365","0.49303487","0.49203402","0.4916478","0.49137795","0.4911951","0.49102816","0.49098662","0.4908657","0.48982143","0.48956963","0.4893658","0.48830053","0.4881267","0.48803854","0.48726454","0.4867084","0.48571783","0.48517027","0.4847931","0.48323813","0.48311725","0.48277515","0.48235112","0.48208755","0.48200697","0.4818996","0.48162922","0.48029476","0.47991198","0.47977433","0.47965086","0.4784856","0.47782007","0.47722843","0.47705016","0.47687912","0.47685122","0.47680575","0.4767273"],"string":"[\n \"0.610253\",\n \"0.5766414\",\n \"0.5608554\",\n \"0.56082743\",\n \"0.5588019\",\n \"0.55230093\",\n \"0.5471639\",\n \"0.54091835\",\n \"0.5401123\",\n \"0.5401123\",\n \"0.5352664\",\n \"0.53298753\",\n \"0.5326704\",\n \"0.5319585\",\n \"0.53189176\",\n \"0.53112936\",\n \"0.53038687\",\n \"0.5290001\",\n \"0.52694154\",\n \"0.5253243\",\n \"0.52476627\",\n \"0.523922\",\n \"0.52297443\",\n \"0.5229701\",\n \"0.518845\",\n \"0.51817435\",\n \"0.5160045\",\n \"0.5155831\",\n \"0.5155831\",\n \"0.5151278\",\n \"0.51422364\",\n \"0.51406705\",\n \"0.51399904\",\n \"0.5137865\",\n \"0.5116423\",\n \"0.51093125\",\n \"0.5108477\",\n \"0.51031625\",\n \"0.50941175\",\n \"0.50769424\",\n \"0.5057904\",\n \"0.505595\",\n \"0.505425\",\n \"0.5043357\",\n \"0.5036213\",\n \"0.5026084\",\n \"0.5015972\",\n \"0.50066376\",\n \"0.50049156\",\n \"0.5004661\",\n \"0.49843317\",\n \"0.49755844\",\n \"0.49689588\",\n \"0.4967986\",\n \"0.49528\",\n \"0.4951237\",\n \"0.49434888\",\n \"0.49409115\",\n \"0.49369526\",\n \"0.4934715\",\n \"0.49345365\",\n \"0.49303487\",\n \"0.49203402\",\n \"0.4916478\",\n \"0.49137795\",\n \"0.4911951\",\n \"0.49102816\",\n \"0.49098662\",\n \"0.4908657\",\n \"0.48982143\",\n \"0.48956963\",\n \"0.4893658\",\n \"0.48830053\",\n \"0.4881267\",\n \"0.48803854\",\n \"0.48726454\",\n \"0.4867084\",\n \"0.48571783\",\n \"0.48517027\",\n \"0.4847931\",\n \"0.48323813\",\n \"0.48311725\",\n \"0.48277515\",\n \"0.48235112\",\n \"0.48208755\",\n \"0.48200697\",\n \"0.4818996\",\n \"0.48162922\",\n \"0.48029476\",\n \"0.47991198\",\n \"0.47977433\",\n \"0.47965086\",\n \"0.4784856\",\n \"0.47782007\",\n \"0.47722843\",\n \"0.47705016\",\n \"0.47687912\",\n \"0.47685122\",\n \"0.47680575\",\n \"0.4767273\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6723716"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14887,"cells":{"query":{"kind":"string","value":"Shows a category item"},"document":{"kind":"string","value":"def showItem(category_item_id):\n return render_template('item.html', item=db.findItem(id=category_item_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 showCategory(category_id):\n category = session.query(Category).\\\n filter_by(id=category_id).one()\n item = session.query(Item).\\\n filter_by(category_id=category.id)\n return render_template('item.html', category=category, item=item)","def showItem(category_id):\n category = session.query(Category).filter_by(id=category_id).one()\n items = session.query(Item).filter_by(category_id=category_id).all()\n\n return render_template('items.html', items=items, category=category)","def view_category(cat_id):\n session['target'] = url_for('view_category', cat_id=cat_id)\n sqlsession = SQLSESSION()\n category = sqlsession.query(Category).filter_by(id=cat_id).first()\n categories = sqlsession.query(Category).all()\n items = sqlsession.query(Item).filter_by(category_id=cat_id).all()\n return render_template(\"view_category.html\",\n category=category,\n categories=categories,\n items=items,\n item_title=category.name + \" Items\")","def show_item(category, item):\n # Detect login status\n login_status = None\n if 'email' in login_session:\n login_status = True\n # Provide state token to enable Google Sign-In\n state = login_session['state']\n # Query database with SQLAlchemy to show selected category and item\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n item = (session.query(Items)\n .filter_by(name=item.replace('-', ' '), category_id=category.id)\n .one())\n # Render webpage\n return render_template('show_item.html',\n item=item,\n category=category,\n login_status=login_status,\n CLIENT_ID=CLIENT_ID,\n STATE=state)","def show_category(category):\n # Detect login status\n login_status = None\n if 'email' in login_session:\n login_status = True\n # Provide state token to enable Google Sign-In\n state = login_session['state']\n # Query database with SQLAlchemy to show all categories\n categories = (session.query(Categories)\n .order_by(Categories.name)\n .all())\n # Query database with SQLAlchemy to show selected category and items\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n category_items = (session.query(Items)\n .filter_by(category_id=category.id)\n .order_by(Items.name)\n .all())\n category_items_count = (session.query(Items)\n .filter_by(category_id=category.id)\n .count())\n # Render webpage\n return render_template('show_category.html',\n categories=categories,\n category_name=category.name,\n category_items=category_items,\n category_items_count=category_items_count,\n login_status=login_status,\n CLIENT_ID=CLIENT_ID,\n STATE=state)","def cli(ctx, category_id):\n return ctx.ti.categories.show_category(category_id)","def showItems(category_id):\r\n # validation\r\n category = session.query(Category).filter_by(id=category_id).first()\r\n if not category:\r\n flash('Attempt to view non-existent category')\r\n return redirect(url_for('showCategories'))\r\n\r\n # authorization\r\n items = session.query(Item).filter_by(category_id=category_id).all()\r\n if 'username' not in login_session or\\\r\n login_session['user_id'] != category.user_id:\r\n return render_template(\"publicShowItems.html\", category=category,\r\n items=items)\r\n\r\n return render_template(\"showItems.html\", category=category, items=items,\r\n logged_in_user_id=login_session['user_id'])","def items_category(request, category_slug):\n\n category = get_object_or_404(Category, slug=category_slug)\n items = Item.objects.filter(category=category)\n\n context = {\n 'category': category,\n 'items': items,\n }\n\n return render(request, 'category/items_category.html', context)","def view_item(item_id):\n session['target'] = url_for('view_item', item_id=item_id)\n sqlsession = SQLSESSION()\n item = sqlsession.query(Item, Category).join(Category)\\\n .filter(Item.id == item_id).first()\n return render_template(\"view_item.html\", item=item)","def show_category_items(category_id):\n all_categories = session.execute(\n 'SELECT category.name, category.id, count(item.id) AS item_count '\n 'FROM category LEFT JOIN item ON category.id = item.category_id '\n 'GROUP BY category.name, category.id')\n category = session.query(Category).filter(Category.id == category_id).first()\n items = session.query(Item).filter(Item.category_id == category_id)\n item_count = items.count()\n return render_template('category_items.html',\n all_categories=all_categories,\n category=category,\n items=items,\n item_count=item_count,\n login_session=login_session)","def show(self, item_id):\n pass","def showItemsByCategory(category_id):\n createSession()\n categories = db.getIndexCategories()\n category = db.getByCategory(category_id)\n items = db.getItemsByCategory(category_id)\n return render_template('category.html',\n main_category=category,\n categories=categories,\n category_id=category_id,\n items=items,\n user_id=login_session.get('user_id'),\n STATE=login_session.get('state'))","def showCategoryItems(category_id):\r\n session = DBSession()\r\n category = session.query(Category).filter_by(id=category_id).one()\r\n creator = getUserInfo(category.user_id)\r\n items = session.query(Item).filter_by(\r\n category_id=category.id).order_by(asc(Item.name))\r\n # or creator.id != login_session['user_id']:\r\n if 'username' in login_session:\r\n return render_template('items.html', category=category, items=items)\r\n else:\r\n return render_template('itemspublic.html', category=category, items=items, creator=creator)","def display_item(categories, item, item_id, initial_category_id):\n if item:\n # Item already exists - display on page\n return render_template('item_edit.html', item_id=item_id, item_name=item.Item.name,\n item_description=item.Item.description, item_category=item.Item.category,\n item_category_id=item.Item.category_id, categories=categories,\n login_session=login_session,\n csrf_token=generate_csrf_token())\n else:\n print('initial_category_id', initial_category_id)\n # Default fields for creating a new item\n return render_template('item_edit.html', item_id=0, item_name=\"\",\n item_description=\"\", item_category=\"\",\n item_category_id=initial_category_id, categories=categories,\n login_session=login_session, initial_category_id=initial_category_id,\n csrf_token=generate_csrf_token())","def category(request):\n\n return render(request, \"core/category_list.html\", {\n \"category_list\": Category.objects.all()\n })","def show_category(category, page):\n per_page = current_app.config['POSTS_PER_PAGE']\n category = Category.query.filter_by(name=category).first() or abort(404)\n posts = category.posts.order_by(Post.id.desc())\n if not session.get('logged_in'): posts = posts.filter_by(visible=True)\n items = posts.limit(per_page).offset((page - 1) * per_page).all()\n pagination = Pagination(posts, page=page, per_page=per_page, \n total=posts.count(), items=items)\n flash(\"Posts in category '%s'\" % category.name)\n return render_template('posts.html', pagination=pagination,\n endpoint_func=lambda x: url_for('main.show_category', \n category=category.name, page=x))","def display_fav_cats():\n\n #display cat general info from db\n #have a delete button/option\n #commit changes to the db\n #if the user clicks the cat for more details, redirect to /more-details/<int:cat_id>","def category(request, slug):\n categry = get_object_or_404(Category,slug=slug)\n story_list = Story.objects.filter(category=category)\n heading = \"Category: %s\" % category.label\n return render_to_response('cms/story_list.html', locals())","def showItems(category_id):\n\n category = session.query(Category).filter_by(id=category_id).one()\n items = session.query(ListItem).filter_by(category_id=category_id).all()\n creator = getUserInfo(category.user_id)\n if 'user_id' in login_session:\n if category.user_id != login_session['user_id']:\n return render_template('pubitems.html',\n items=items,\n category=category,\n creator=creator,\n user=getUserInfo(login_session['user_id']))\n else:\n return render_template('items.html',\n items=items,\n category=category,\n user=getUserInfo(login_session['user_id']))\n else:\n return render_template('pubitems.html',\n items=items,\n category=category,\n creator=creator)","def render_category_page(\r\n self, client_id, state, user_id, user_name, category_id):\r\n category = self._db_manager.get_category(category_id)\r\n if category is None:\r\n flash(\"Invalid category.\")\r\n return\r\n items = self._db_manager.get_category_items(category_id)\r\n return render_template(\r\n \"category_view.html\",\r\n client_id=client_id,\r\n state=state,\r\n is_logged_in=user_id is not None,\r\n is_creator=category[\"user_id\"] == user_id,\r\n user_name=user_name,\r\n category=category,\r\n items=items\r\n )","def view(request, category):\r\n return render(request, 'categories/view.html', {\r\n 'title': category.name,\r\n 'category': category,\r\n 'articles': Article.objects.select_related('author','author__profile','category').filter(category=category, status=Article.PUBLISHED),\r\n })","def show_cat(slug):\n cat = Category.query.filter_by(slug=slug).first()\n return redirect(url_for('articles.show_all') + '?c=' + str(cat.id))","def goto_category_by_title(self,category):\n\n return self.catbrowser.goto_category_by_title(category)","def category_items(category_id):\n\n items = Item.query.filter(\n Item.category_id == category_id,\n Item.user_id == current_user.id\n ).all()\n categories = Category.query.filter(\n Category.user_id == current_user.id).all()\n if not categories:\n flash(\"Couldn't find this category\", category='warning')\n\n return render_template(\n 'index.html',\n categories=categories,\n items=items,\n current_category_id=category_id)","def show_category(update, context):\n query = update.callback_query\n bot = context.bot\n # loads json received from callback_data into dictionary\n ids = json.loads(query.data)\n category_id = ids['category_id']\n keyboard = []\n\n products = menu[category_id]['products']\n # iterates over all products in selected category\n for product_id in products.keys():\n product = products[product_id]\n # add each product to keyboard with id information as callback_data\n keyboard.append([InlineKeyboardButton(product['name'] + \" \" + product['price'],\n callback_data=json.dumps({\"category_id\": category_id,\n \"product_id\": product_id}))])\n\n reply_markup = InlineKeyboardMarkup(keyboard)\n # edits last message to keyboard with all products from category\n bot.edit_message_text(chat_id=query.message.chat_id,\n message_id=query.message.message_id,\n text='Select desired food in ' + menu[category_id]['category'] + \":\",\n reply_markup=reply_markup)\n # notify ConversationHandler of THIRD stage\n return THIRD","async def category(self,ctx):\n await ctx.send(\"Yes this is a category.\")","def showCategories():\n categories = session.query(Category).order_by(asc(Category.name))\n return render_template('categories.html', categories=categories)","def show_categories():\n categories = session.query(Category).all()\n username = login_session.get('username')\n user_id = login_session.get('user_id')\n provider = login_session.get('provider')\n if username is not None:\n username = login_session.get('username')\n return render_template(\"categories.html\", categories=categories,\n username=username, user_id=user_id,\n provider=provider)","def showCategoryDetails(cat_id):\n\n category = Category.query.get(cat_id)\n # get all the poses under that category\n all_poses = db.session.query(Pose).join(PoseCategory).filter(PoseCategory.cat_id==cat_id).all()\n\n return render_template(\"category-details.html\", all_poses=all_poses, category=category)","def category(request, category_id, template_name='doppler/shift/catalog/category.haml'):\n category = get_object_or_404(Category, pk=category_id, enabled=True)\n products = category.enabled_products\n subcategories = category.children.filter(enabled=True)\n return render_to_response(\n template_name,\n {\n 'category': category,\n 'products': products,\n 'subcategories': subcategories,\n },\n context_instance=RequestContext(request))","def items_for_category(category_id):\n items_under_category = session.query(\n Item).filter_by(category_id=category_id).all()\n all_categories = session.query(Category).all()\n category = get_category_in_list(category_id, all_categories)\n return render_template(\n 'views/items.html',\n items=items_under_category,\n current_category=category,\n categories=all_categories)","def test_view_category_by_id(self):\n rv = self.client().post('/categories/', data=self.category)\n self.assertEqual(rv.status_code, 201)\n result_in_json = json.loads(rv.data.decode('utf-8').replace(\"'\", \"\\\"\"))\n result = self.client().get(\n '/categories/{}'.format(result_in_json['category_name']))\n self.assertEqual(result.status_code, 200)\n self.assertIn('Stews', str(result.data))","def showCategories():\n\n categories = session.query(Category).order_by(asc(Category.name))\n if 'user_id' in login_session:\n return render_template('categories.html',\n categories=categories,\n user=getUserInfo(login_session['user_id']))\n else:\n return render_template('pubcategories.html', categories=categories)","def show_category_specialist():\n\n categories = Category.query.order_by(Category.id.asc())\n specialists = Specialist.query.order_by(Specialist.id.asc())\n return render_template('general/category_specialist.html', title='Categories-Specialists', \n categories=categories, specialists=specialists)","def category(request, category):\n \n # query for all active listings in selected category\n auctions = Auction_listing.objects.filter(category=category, active=True)\n current_bid = Auction_listing.objects.annotate(max_bid=Max('bid__bid'))\n \n return render(request, 'auctions/category.html', {\n 'auctions': auctions,\n 'category': category,\n \"current_bid\": current_bid\n })","def create_item_page():\n catagories = [c.name for c in Catagory.fetch_all()]\n return render_template('add_item.html', catagories=catagories, values={})","def showCategories():\r\n categories = session.query(Category).all()\r\n if 'username' not in login_session:\r\n return render_template(\"publicCategories.html\", categories=categories)\r\n return render_template(\"categories.html\", categories=categories)","def faqitem_show(request,item_container):\n app_name = 'faqitem'\n parent = item_container.get_parent()\n if parent.item.has_comments:\n comments = item_comment(request, item_container=item_container)\n else:\n comments = ''\n vars = get_item_vars_show(request, item_container, app_name)\n vars['comments'] = comments\n return render_to_response ( 'app/faqitem/base-item.html', vars )","def get_item(self, item_id: int, category: str = None):\n if category:\n # ensuring that it will be in lowercase\n category = category.lower()\n\n if not category or not category in self.item_categories:\n # Assuming that if category isnt set, we are searching for anime\n category = \"anime\"\n\n search_url = f\"{SITE_URL}/{self.item_categories[category]}/{item_id}\"\n\n return self.fetch_url(search_url)","def show_categories(self):\n cat_model = TreeModel(('Categories', ))\n self.categoriesView.setModel(cat_model)\n\n categories = self.orm.fetch_parents()\n for category in categories:\n item = TreeItem(category, cat_model.rootItem)\n cat_model.rootItem.appendChild(item)\n\n subs = self.orm.fetch_subcategories_for_parent(category)\n\n for sub in subs:\n sub_item = TreeItem(sub, item)\n item.appendChild(sub_item)\n\n self.categoriesView.expandAll()","def cat_details(cat_id, shelter_id):\n\n shelter = petfinder.shelter_data_map(shelter_id)\n shelter = list(shelter.values())\n cat = petfinder.cat_data_map(cat_id)\n cat = list(cat.values())\n\n return render_template('more_details.html',\n shelter=shelter,\n cat=cat)\n\n #if user selects <3 to favorite a cat then redirct to the login page","def category(request):\r\n\tcategory = request.GET.get('category')\r\n\tgames = Game.objects.filter(category=category)\r\n\treturn render(request, 'home.html', {'games': games, 'MEDIA_URL': settings.MEDIA_URL})","def render_item_page(self, client_id, state, user_id, user_name, item_id):\r\n item = self._db_manager.get_item(item_id)\r\n if item is None:\r\n flash(\"Invalid item.\")\r\n return\r\n category = self._db_manager.get_category(item[\"category_id\"])\r\n if category is None:\r\n # this should not happen unless there is a concurrent delete\r\n flash(\"Sorry, something went wrong.\")\r\n return\r\n return render_template(\r\n \"item_view.html\",\r\n client_id=client_id,\r\n state=state,\r\n is_logged_in=user_id is not None,\r\n is_creator=item[\"user_id\"] == user_id,\r\n user_name=user_name,\r\n category=category,\r\n item=item\r\n )","def render_add_item_page(\r\n self, client_id, state, user_id, user_name, category_id):\r\n categories = self._db_manager.get_category_list(user_id)\r\n if len(categories) == 0:\r\n flash(\"You have created no categories to add items to.\")\r\n return\r\n return render_template(\r\n \"item_add.html\",\r\n client_id=client_id,\r\n state=state,\r\n is_logged_in=True,\r\n user_name=user_name,\r\n category_id=category_id,\r\n categories=categories\r\n )","def info(self, categories=()):\n pp = pprint.PrettyPrinter(indent=4)\n print_text_box('Category')\n data = self.manager.data[\"category\"]\n if any(categories):\n data = self._get_filtered_category_data(data, categories)\n pp.pprint(data)\n print('')","def __str__(self):\n return self.category_name","def categories(request, pk):\n if Category.objects.filter(item_type_id=pk).exists(): # Checks if product_category exists with given id.\n all_categories = Category.objects.filter(item_type_id=pk)\n else:\n return Response(messages.CATEGORY_ITEM_DOES_NOT_EXIST, status=status.HTTP_404_NOT_FOUND)\n if request.method == 'GET':\n category_serializer = CategorySerializer(all_categories, many=True)\n\n return Response(category_serializer.data[::-1], status=status.HTTP_200_OK)","def show_item(self, show_item):\n\n self._show_item = show_item","def CategoryView(request, cats):\r\n\r\n context = {\r\n 'posts': Post.objects.filter(category=cats.replace('-', ' ')).all(),\r\n 'cats': cats,\r\n 'cat_menu': Category.objects.all()\r\n }\r\n return render(request, 'blog/categories.html', context)","def display_by_category(request, category):\n if request.method == \"POST\":\n form = SearchForm(request.POST)\n if form.is_valid():\n products = AuctionListing.objects.filter(buyer=None).filter(\n category__iexact=category).filter(title__icontains=form.cleaned_data[\"query\"])\n else:\n products = AuctionListing.objects.filter(buyer=None).filter(\n category__iexact=category)\n else:\n products = AuctionListing.objects.filter(buyer=None).filter(\n category__iexact=category)\n form = None\n bids = []\n for product in products:\n bid = product.bids.all().aggregate(Max(\"bid\")).get(\"bid__max\")\n bids.append(bid)\n return render(request, \"auctions/index.html\", {\n \"zip_products_bids\": zip(products, bids),\n \"category\": category,\n \"form\": form,\n \"title\": \"Active Listing\",\n })","def show_item_json(category, item):\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n item = (session.query(Items)\n .filter_by(name=item.replace('-', ' '))\n .one())\n return jsonify(item=[item.serialize])","def show_category_json(category):\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n category_items = (session.query(Items)\n .filter_by(category_id=category.id)\n .order_by(Items.name)\n .all())\n return jsonify(category=[category.serialize],\n items=([category_items.serialize\n for category_items in category_items]))","def categories_menu():\n categories = ['EU-affairs', 'Economy', 'Security', 'Society', 'World']\n\n for category in categories:\n url = build_url({'mode': 'Topic', 'foldername': category, 'page': 1})\n li = xbmcgui.ListItem(category, iconImage='DefaultFolder.png')\n xbmcplugin.addDirectoryItem(handle=ADDON_HANDLE, url=url, listitem=li, isFolder=True)\n\n xbmcplugin.endOfDirectory(ADDON_HANDLE)","def getcatagory(itemID, page=1):\n\n if type(itemID) == int:\n itemID = \"%23{0}\".format(itemID)\n\n return harvest(GET_CATAGORY_URL, itemID, page)","def item_detail(request, slug):\n\n item = get_object_or_404(Item, slug=slug)\n\n context = {\n 'item': item,\n }\n\n return render(request, 'items/item_detail.html', context)","def newItem():\n if request.method == 'POST':\n db.createItem(\n title=request.form['title'],\n description=request.form['description'],\n category_id=request.form['category'],\n user_id=login_session['user_id'])\n flash(\"New catalog item created!\", 'success')\n return redirect(url_for('showCatalog'))\n return render_template('new_item.html', categories=db.getAllCategories())","def read_category_item(category_item_id):\n item = session.query(CatalogItem).filter_by(id=category_item_id).one()\n return item","def getCategory():","def showCatalog(sport_id):\n\n sport = session.query(Sport).filter_by(id=sport_id).one()\n items = session.query(Item).filter_by(sport_id=sport_id).all()\n return render_template('catalog.html', sport=sport, items=items)","def showItemJSON(category_id, item_id):\r\n session = DBSession()\r\n item = session.query(Item).filter_by(id=item_id).one()\r\n return jsonify(Item=item.serialize)","def newItem(category_id):\n editedCategory = session.query(Category). \\\n filter_by(id=category_id).one()\n if editedCategory.user_id != login_session['user_id']:\n flash('You are not authorized to edit this Category.\\\n Please create your own Category in order to edit.')\n return redirect(url_for('showCategory', category_id=category_id))\n if request.method == 'POST':\n newItem = Item(\n name=request.form['name'],\n description=request.form['description'],\n price=request.form['price'],\n category_id=category_id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Item created')\n return redirect(url_for('showCategory',\n category_id=category_id))\n else:\n return render_template('newItem.html', category_id=category_id)","def newListItem(category_id):\n\n if 'username' not in login_session:\n return redirect('/login')\n\n category = session.query(Category).filter_by(id=category_id).one()\n\n if category.user_id != login_session['user_id']:\n flash('You are not the creator of %s category, and cannot modify it' %\n category.name)\n return redirect(url_for('showItems', category_id=category.id))\n if request.method == 'POST':\n if \"btn_new\" in request.form:\n newItem = ListItem(name=request.form['name'],\n description=request.form['description'],\n category_id=category_id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Catalog Item: %s Successfully Created' % (newItem.name))\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return render_template('newitem.html',\n category_id=category_id,\n user=getUserInfo(login_session['user_id']))","def food_item(request, food_id):\n\n food = get_object_or_404(Nutrition, pk=food_id)\n\n context = {\n 'food': food,\n }\n\n return render(request, 'nutrition/food.html', context)","def category_details_url(id):\n return reverse('category:category-detail', args=[id])","def show_categories():\n for category in NEWS_CATEGORIES:\n print(category)","def update_item_page(item_name, catagory_name):\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\n catagories = [c.name for c in Catagory.fetch_all()]\n return render_template(\n 'edit_item.html',\n catagories=catagories,\n values={\n 'name': item.name,\n 'catagory': item.catagory_name,\n 'description': item.description\n },\n )","def __repr__(self):\n return f\"Category=(id={self.id},category_name={self.category_name},category_slug={self.category_slug})\"","def test_get_item_by_id(self):\n response = self.client.get('/api/v1/category/1',\n headers=self.attendant_headers)\n self.assertEqual(response.status_code, 200)","def __str__(self):\n \n return \"Category ID: %s %s\" % (self.category_id, self.name)","def retrieve(self, request, pk=None):\n try:\n category = ItemCategory.objects.get(pk=pk)\n serializer = ItemCategorySerializer(category, context={'request': request})\n return Response(serializer.data)\n except Exception as ex:\n return HttpResponseServerError(ex)","def category(self):\n return self._ctx.get(\"name\", self._ctx[\"id\"])","def edit_item_details(item_id):\n category_id = None\n if 'category_id' in request.args:\n category_id = int(request.args['category_id'])\n if 'userid' not in login_session:\n flash('Unfortunately you need to be logged in to make changes', 'error')\n return redirect(url_for('show_homepage'))\n\n item = None\n if item_id != 0:\n item = is_user_the_creator(item_id)\n if request.method == 'GET':\n categories = session.query(Category).order_by(asc(Category.name)).all()\n return display_item(categories, item, item_id, category_id)\n else:\n return save_item(item, item_id)","def browse_category(request):\n\n result = {'categories':[], 'products':[]}\n\n u = request.user\n\n page = request.POST.get('page', 1)\n\n cat = Category.objects.get(id=request.POST['cat_id'])\n if cat.children.count() > 0:\n result['categories'] = [c.get_json() for c in cat.children.all()]\n else:\n # display items\n result = Product.objects.filter_category(cat.category_id, page, u) \n\n return JSONHttpResponse(result)","def editItem(category_item_id):\n editedItem = db.findItem(id=category_item_id)\n if editedItem.user_id != login_session['user_id']:\n return not_authorized()\n if request.method == 'POST':\n db.updateItem(editedItem, request.form)\n return redirect(url_for('showCatalog'))\n return render_template(\n 'edit_item.html', categories=db.getAllCategories(), item=editedItem)","def category_view(slug, page):\n board_id = h.get_board_id()\n user = g.user\n\n h.require_board_access(board_id, user.id)\n\n category = board_category_query_service.find_category_by_slug(\n board_id, slug\n )\n\n if category is None:\n abort(404)\n\n if category.hidden:\n abort(404)\n\n if user.authenticated:\n board_last_view_service.mark_category_as_just_viewed(\n category.id, user.id\n )\n\n include_hidden = service.may_current_user_view_hidden()\n topics_per_page = service.get_topics_per_page_value()\n\n topics = board_topic_query_service.paginate_topics_of_category(\n category.id, page, topics_per_page, include_hidden=include_hidden\n )\n\n service.add_topic_creators(topics.items)\n service.add_topic_unseen_flag(topics.items, user)\n\n return {\n 'category': category,\n 'topics': topics,\n }","def newItem(category_id):\n category = session.query(Category).filter_by(id=category_id).one()\n if request.method == 'POST':\n newItem = Item(name=request.form['name'],\n description=request.form['description'],\n price=request.form['price'], category_id=category.id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Item %s Successfully Created' % (newItem.name))\n return redirect(url_for('showItem', category_id=category.id))\n else:\n return render_template('newitem.html', category_id=category.id)","def show_categories(update, context):\n query = update.callback_query\n bot = context.bot\n\n keyboard = []\n # iterate over every category\n for category_id in menu.keys():\n # add category to keyboard\n keyboard.append([InlineKeyboardButton(str(menu[category_id]['category']),\n callback_data=json.dumps({\"category_id\": category_id,\n \"product_id\": 0}))])\n\n reply_markup = InlineKeyboardMarkup(keyboard)\n\n # edits last message to keyboard with all categories\n bot.edit_message_text(chat_id=query.message.chat_id,\n message_id=query.message.message_id,\n text='Please choose :',\n reply_markup=reply_markup)\n # notify ConversationHandler of SECOND stage\n return SECOND","def read_item(item_name, catagory_name):\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\n return render_template('item.html', item=item)","def category_view(slug, page):\n board_id = h.get_board_id()\n user = g.user\n\n h.require_board_access(board_id, user.id)\n\n category = board_category_query_service.find_category_by_slug(\n board_id, slug\n )\n\n if category is None:\n abort(404)\n\n if category.hidden:\n abort(404)\n\n if user.authenticated:\n board_last_view_service.mark_category_as_just_viewed(\n category.id, user.id\n )\n\n include_hidden = service.may_current_user_view_hidden()\n topics_per_page = service.get_topics_per_page_value()\n\n topics = board_topic_query_service.paginate_topics_of_category(\n category.id, include_hidden, page, topics_per_page\n )\n\n service.add_topic_creators(topics.items)\n service.add_topic_unseen_flag(topics.items, user)\n\n return {\n 'category': category,\n 'topics': topics,\n }","def render_edit_category_page(\r\n self, client_id, state, user_id, user_name, category_id):\r\n category = self._db_manager.get_category(category_id)\r\n if category is None:\r\n flash(\"Invalid category.\")\r\n return\r\n if category[\"user_id\"] != user_id:\r\n # the check whether the user owns the category can only be made\r\n # here since the database needs to be consulted\r\n flash(\"Only the original creator can edit a category.\")\r\n return\r\n return render_template(\r\n \"category_edit.html\",\r\n client_id=client_id,\r\n state=state,\r\n is_logged_in=True,\r\n user_name=user_name,\r\n category=category\r\n )","def __str__(self):\n return self.cat_name","def items(request, pk):\n\n if Item.objects.filter(category_id=pk).exists(): # Checks if product_category exists with given id.\n all_items = Item.objects.filter(category_id=pk)\n else:\n return Response(messages.ITEMS_DOES_NOT_EXIST, status=status.HTTP_404_NOT_FOUND)\n if request.method == 'GET':\n item_serializer = ItemSerializer(all_items, many=True)\n return Response(item_serializer.data[::-1], status=status.HTTP_200_OK)","def new_item():\n if request.method == 'POST':\n new_item = Item(\n category_id=int(request.form['category']),\n name=request.form['name'],\n description=request.form['description'],\n created_date=datetime.datetime.now(),\n user_id=login_session['user_id'])\n session.add(new_item)\n session.commit()\n return redirect(\n url_for(\n 'item_details',\n category_id=new_item.category_id,\n item_id=new_item.id))\n else:\n categories = session.query(\n Category).all()\n return render_template(\n 'views/add.html',\n categories=categories)","def category(self, category: str):\n\n self._category = category","def deleteCategory(category_id):\n editedCategory = session.query(Category).\\\n filter_by(id=category_id).one()\n editedItem = session.query(Item).\\\n filter_by(category_id=editedCategory.id).all()\n print editedItem\n if editedCategory.user_id != login_session['user_id']:\n flash('You are not authorized to delete this Item.\\\n Please create own Category with items in order to \\\n delete items.')\n return redirect(url_for('showallCategories'))\n else:\n if editedItem:\n flash('Category Deletion not possible. \\\n Please delete the items in Category')\n return redirect(url_for('showCategory',\n category_id=category_id))\n elif request.method == 'POST':\n session.delete(editedCategory)\n session.commit()\n flash('Category Deletion successfull')\n return redirect(url_for('showallCategories'))\n else:\n return render_template(\n 'deleteCategory.html', category_id=category_id,\n category=editedCategory)","def viewItem(sport_id, item_id):\n\n sport = session.query(Sport).filter_by(id=sport_id).one()\n item = session.query(Item).filter_by(id=item_id).one()\n return render_template('viewitem.html', sport_id=sport_id, item_id=item_id,\n item=item, sport=sport)","async def cat(self, ctx):\n async with ctx.session.get('https://api.thecatapi.com/v1/images/search') as resp:\n if resp.status != 200:\n return await ctx.send('No cat found :(')\n js = await resp.json()\n await ctx.send(embed=discord.Embed(title='Random Cat').set_image(url=js[0]['url']))","def view_item(request, product_id):\n\n sizes = None\n forsixes = None\n back_to_cats = None\n\n product = get_object_or_404(Product, pk=product_id)\n reviews = Review.objects.filter(product=product).order_by('-date_posted')\n\n if product.is_sizes:\n try:\n sizes = Size.objects.get(name=product.name)\n except Size.DoesNotExist:\n messages.info(request, (\n \"This item has only one size\")\n )\n\n if product.is_for_six:\n try:\n forsixes = Forsix.objects.get(name=product.name)\n except Forsix.DoesNotExist:\n messages.info(request, (\n \"This item has only one size\")\n )\n\n if 'r' in request.GET:\n back_to_cats = request.GET['r']\n print(back_to_cats)\n\n context = {\n 'product': product,\n 'reviews': reviews,\n 'sizes': sizes,\n 'forsixes': forsixes,\n 'back_to_cats': back_to_cats\n }\n\n return render(request, 'products/view_item.html', context)","def delete_item_page(item_name, catagory_name):\n return render_template(\n 'delete_item.html', item_name=item_name, catagory_name=catagory_name\n )","def show_item_by_id(plugin, item_id):\n import alltheitems.item_page\n return alltheitems.item_page.item_page(plugin + ':' + item_id)","def edit_item(category, item):\n # Verify user login. If not, redirect to login page.\n login_status = None\n if 'email' in login_session:\n login_status = True\n else:\n flash('Please log in.')\n return redirect(url_for('home'))\n # Query database with SQLAlchemy to display categories on page\n categories = session.query(Categories).all()\n if request.method == 'POST':\n # Query database with SQLAlchemy and store queries as objects\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n item = (session.query(Items)\n .filter_by(name=item.replace('-', ' '))\n .one())\n # Get form fields submitted by user, or retain item info\n name = request.form['name'] if request.form['name'] else item.name\n url = request.form['url'] if request.form['url'] else item.url\n if request.form['photo_url']:\n photo_url = request.form['photo_url']\n else:\n photo_url = item.photo_url\n if request.form['description']:\n description = request.form['description']\n else:\n description = item.description\n category = request.form['item_category']\n # Retrieve the database ID of the item's category\n category_id = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n # Get user's database ID\n user_db_id = (session.query(Users)\n .filter_by(email=login_session['email'])\n .one()).id\n # Get database ID of creator\n creator_db_id = item.creator_db_id\n print(\"Current user's database primary key id is {}.\"\n .format(user_db_id))\n print(\"Item creator's database primary key id is {}.\"\n .format(creator_db_id))\n print('Item to edit is \"{}\".'.format(item.name))\n # Only allow creator to edit. If not, redirect to login.\n if user_db_id != creator_db_id:\n flash('Only the creator can edit. Please log in as creator.')\n return redirect(url_for('home'))\n # Store edits in an object\n edited_item = Items(name=name,\n url=url,\n photo_url=photo_url,\n description=description,\n category_id=category_id.id,\n creator_db_id=user_db_id)\n # Overwrite item object with new info from edited_item object\n item.name = edited_item.name\n item.url = edited_item.url\n item.photo_url = edited_item.photo_url\n item.description = edited_item.description\n item.category_id = edited_item.category_id\n session.add(item)\n session.commit()\n print('Item \"{}\" edited.'.format(edited_item.name))\n # Return to homepage\n return redirect(url_for('home'))\n else:\n # Query database with SQLAlchemy to display categories on page\n categories = session.query(Categories).all()\n # Render webpage\n return render_template('edit_item.html',\n categories=categories,\n item=item,\n login_status=login_status)","def test_view_categories(self):\n res = self.client().post('/categories/', data=self.category)\n self.assertEqual(res.status_code, 201)\n res = self.client().get('/categories/')\n self.assertEqual(res.status_code, 200)\n self.assertIn('Stews', str(res.data))","def category(self) -> str:\n return pulumi.get(self, \"category\")","def catalog():\n session['target'] = \"/\"\n sqlsession = SQLSESSION()\n items = sqlsession.query(Item, Category)\\\n .join(Category).order_by(Item.create_date).limit(10)\n categories = sqlsession.query(Category).all()\n return render_template(\"catalog.html\",\n items=items,\n categories=categories,\n item_title=\"Latest Items\")","def test_get_a_category(self):\n self.test_add_category_success()\n response = self.client.get('/categories/1',\n headers={\"Authorization\": self.token})\n self.assertEqual(response.status_code, 200)\n self.assertIn('asian', response.data.decode())","def category_index(request, slug_category):\n selected_category = get_object_or_404(Category, slug=slug_category)\n category_entries = selected_category.entry_set.filter(status=2).order_by('-pub_date')\n paginator = Paginator(category_entries, 4)#4 posts/page\n try:\n page = int(request.GET.get('page', '1'))\n except ValueError:\n page = 1\n try:\n entries = paginator.page(page)\n except (EmptyPage, InvalidPage):\n entries = paginator.page(paginator.num_pages)\n return render_to_response('blog/category_index.html', {'entries':entries, 'category':selected_category}, RequestContext(request))","def getcategory(self):\n\n response = requests.get(\"https://fr.openfoodfacts.org/categories.json\")\n\n data = response.json()\n\n self.rawcategorydata = data","def createItem(category_id):\r\n if 'username' not in login_session:\r\n return redirect(url_for('showLogin'))\r\n if request.method == 'POST':\r\n session = DBSession()\r\n item = Item(name=request.form['name'],\r\n description=request.form['description'],\r\n category_id=category_id,\r\n user_id=login_session['user_id'])\r\n session.add(item)\r\n session.commit()\r\n return redirect(url_for('showCategoryItems', category_id=category_id))\r\n else:\r\n return render_template('newitem.html', category_id=category_id)","def showallCategories():\n category = session.query(Category).all()\n onedayearly = datetime.timedelta(hours=24)\n since = datetime.datetime.now() - onedayearly\n latest = session.query(Item).filter(Item.date > since)\n return render_template('category.html', category=category, latest=latest)","def get_category(self) -> str:\n return self.category"],"string":"[\n \"def showCategory(category_id):\\n category = session.query(Category).\\\\\\n filter_by(id=category_id).one()\\n item = session.query(Item).\\\\\\n filter_by(category_id=category.id)\\n return render_template('item.html', category=category, item=item)\",\n \"def showItem(category_id):\\n category = session.query(Category).filter_by(id=category_id).one()\\n items = session.query(Item).filter_by(category_id=category_id).all()\\n\\n return render_template('items.html', items=items, category=category)\",\n \"def view_category(cat_id):\\n session['target'] = url_for('view_category', cat_id=cat_id)\\n sqlsession = SQLSESSION()\\n category = sqlsession.query(Category).filter_by(id=cat_id).first()\\n categories = sqlsession.query(Category).all()\\n items = sqlsession.query(Item).filter_by(category_id=cat_id).all()\\n return render_template(\\\"view_category.html\\\",\\n category=category,\\n categories=categories,\\n items=items,\\n item_title=category.name + \\\" Items\\\")\",\n \"def show_item(category, item):\\n # Detect login status\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n # Provide state token to enable Google Sign-In\\n state = login_session['state']\\n # Query database with SQLAlchemy to show selected category and item\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n item = (session.query(Items)\\n .filter_by(name=item.replace('-', ' '), category_id=category.id)\\n .one())\\n # Render webpage\\n return render_template('show_item.html',\\n item=item,\\n category=category,\\n login_status=login_status,\\n CLIENT_ID=CLIENT_ID,\\n STATE=state)\",\n \"def show_category(category):\\n # Detect login status\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n # Provide state token to enable Google Sign-In\\n state = login_session['state']\\n # Query database with SQLAlchemy to show all categories\\n categories = (session.query(Categories)\\n .order_by(Categories.name)\\n .all())\\n # Query database with SQLAlchemy to show selected category and items\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n category_items = (session.query(Items)\\n .filter_by(category_id=category.id)\\n .order_by(Items.name)\\n .all())\\n category_items_count = (session.query(Items)\\n .filter_by(category_id=category.id)\\n .count())\\n # Render webpage\\n return render_template('show_category.html',\\n categories=categories,\\n category_name=category.name,\\n category_items=category_items,\\n category_items_count=category_items_count,\\n login_status=login_status,\\n CLIENT_ID=CLIENT_ID,\\n STATE=state)\",\n \"def cli(ctx, category_id):\\n return ctx.ti.categories.show_category(category_id)\",\n \"def showItems(category_id):\\r\\n # validation\\r\\n category = session.query(Category).filter_by(id=category_id).first()\\r\\n if not category:\\r\\n flash('Attempt to view non-existent category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n # authorization\\r\\n items = session.query(Item).filter_by(category_id=category_id).all()\\r\\n if 'username' not in login_session or\\\\\\r\\n login_session['user_id'] != category.user_id:\\r\\n return render_template(\\\"publicShowItems.html\\\", category=category,\\r\\n items=items)\\r\\n\\r\\n return render_template(\\\"showItems.html\\\", category=category, items=items,\\r\\n logged_in_user_id=login_session['user_id'])\",\n \"def items_category(request, category_slug):\\n\\n category = get_object_or_404(Category, slug=category_slug)\\n items = Item.objects.filter(category=category)\\n\\n context = {\\n 'category': category,\\n 'items': items,\\n }\\n\\n return render(request, 'category/items_category.html', context)\",\n \"def view_item(item_id):\\n session['target'] = url_for('view_item', item_id=item_id)\\n sqlsession = SQLSESSION()\\n item = sqlsession.query(Item, Category).join(Category)\\\\\\n .filter(Item.id == item_id).first()\\n return render_template(\\\"view_item.html\\\", item=item)\",\n \"def show_category_items(category_id):\\n all_categories = session.execute(\\n 'SELECT category.name, category.id, count(item.id) AS item_count '\\n 'FROM category LEFT JOIN item ON category.id = item.category_id '\\n 'GROUP BY category.name, category.id')\\n category = session.query(Category).filter(Category.id == category_id).first()\\n items = session.query(Item).filter(Item.category_id == category_id)\\n item_count = items.count()\\n return render_template('category_items.html',\\n all_categories=all_categories,\\n category=category,\\n items=items,\\n item_count=item_count,\\n login_session=login_session)\",\n \"def show(self, item_id):\\n pass\",\n \"def showItemsByCategory(category_id):\\n createSession()\\n categories = db.getIndexCategories()\\n category = db.getByCategory(category_id)\\n items = db.getItemsByCategory(category_id)\\n return render_template('category.html',\\n main_category=category,\\n categories=categories,\\n category_id=category_id,\\n items=items,\\n user_id=login_session.get('user_id'),\\n STATE=login_session.get('state'))\",\n \"def showCategoryItems(category_id):\\r\\n session = DBSession()\\r\\n category = session.query(Category).filter_by(id=category_id).one()\\r\\n creator = getUserInfo(category.user_id)\\r\\n items = session.query(Item).filter_by(\\r\\n category_id=category.id).order_by(asc(Item.name))\\r\\n # or creator.id != login_session['user_id']:\\r\\n if 'username' in login_session:\\r\\n return render_template('items.html', category=category, items=items)\\r\\n else:\\r\\n return render_template('itemspublic.html', category=category, items=items, creator=creator)\",\n \"def display_item(categories, item, item_id, initial_category_id):\\n if item:\\n # Item already exists - display on page\\n return render_template('item_edit.html', item_id=item_id, item_name=item.Item.name,\\n item_description=item.Item.description, item_category=item.Item.category,\\n item_category_id=item.Item.category_id, categories=categories,\\n login_session=login_session,\\n csrf_token=generate_csrf_token())\\n else:\\n print('initial_category_id', initial_category_id)\\n # Default fields for creating a new item\\n return render_template('item_edit.html', item_id=0, item_name=\\\"\\\",\\n item_description=\\\"\\\", item_category=\\\"\\\",\\n item_category_id=initial_category_id, categories=categories,\\n login_session=login_session, initial_category_id=initial_category_id,\\n csrf_token=generate_csrf_token())\",\n \"def category(request):\\n\\n return render(request, \\\"core/category_list.html\\\", {\\n \\\"category_list\\\": Category.objects.all()\\n })\",\n \"def show_category(category, page):\\n per_page = current_app.config['POSTS_PER_PAGE']\\n category = Category.query.filter_by(name=category).first() or abort(404)\\n posts = category.posts.order_by(Post.id.desc())\\n if not session.get('logged_in'): posts = posts.filter_by(visible=True)\\n items = posts.limit(per_page).offset((page - 1) * per_page).all()\\n pagination = Pagination(posts, page=page, per_page=per_page, \\n total=posts.count(), items=items)\\n flash(\\\"Posts in category '%s'\\\" % category.name)\\n return render_template('posts.html', pagination=pagination,\\n endpoint_func=lambda x: url_for('main.show_category', \\n category=category.name, page=x))\",\n \"def display_fav_cats():\\n\\n #display cat general info from db\\n #have a delete button/option\\n #commit changes to the db\\n #if the user clicks the cat for more details, redirect to /more-details/<int:cat_id>\",\n \"def category(request, slug):\\n categry = get_object_or_404(Category,slug=slug)\\n story_list = Story.objects.filter(category=category)\\n heading = \\\"Category: %s\\\" % category.label\\n return render_to_response('cms/story_list.html', locals())\",\n \"def showItems(category_id):\\n\\n category = session.query(Category).filter_by(id=category_id).one()\\n items = session.query(ListItem).filter_by(category_id=category_id).all()\\n creator = getUserInfo(category.user_id)\\n if 'user_id' in login_session:\\n if category.user_id != login_session['user_id']:\\n return render_template('pubitems.html',\\n items=items,\\n category=category,\\n creator=creator,\\n user=getUserInfo(login_session['user_id']))\\n else:\\n return render_template('items.html',\\n items=items,\\n category=category,\\n user=getUserInfo(login_session['user_id']))\\n else:\\n return render_template('pubitems.html',\\n items=items,\\n category=category,\\n creator=creator)\",\n \"def render_category_page(\\r\\n self, client_id, state, user_id, user_name, category_id):\\r\\n category = self._db_manager.get_category(category_id)\\r\\n if category is None:\\r\\n flash(\\\"Invalid category.\\\")\\r\\n return\\r\\n items = self._db_manager.get_category_items(category_id)\\r\\n return render_template(\\r\\n \\\"category_view.html\\\",\\r\\n client_id=client_id,\\r\\n state=state,\\r\\n is_logged_in=user_id is not None,\\r\\n is_creator=category[\\\"user_id\\\"] == user_id,\\r\\n user_name=user_name,\\r\\n category=category,\\r\\n items=items\\r\\n )\",\n \"def view(request, category):\\r\\n return render(request, 'categories/view.html', {\\r\\n 'title': category.name,\\r\\n 'category': category,\\r\\n 'articles': Article.objects.select_related('author','author__profile','category').filter(category=category, status=Article.PUBLISHED),\\r\\n })\",\n \"def show_cat(slug):\\n cat = Category.query.filter_by(slug=slug).first()\\n return redirect(url_for('articles.show_all') + '?c=' + str(cat.id))\",\n \"def goto_category_by_title(self,category):\\n\\n return self.catbrowser.goto_category_by_title(category)\",\n \"def category_items(category_id):\\n\\n items = Item.query.filter(\\n Item.category_id == category_id,\\n Item.user_id == current_user.id\\n ).all()\\n categories = Category.query.filter(\\n Category.user_id == current_user.id).all()\\n if not categories:\\n flash(\\\"Couldn't find this category\\\", category='warning')\\n\\n return render_template(\\n 'index.html',\\n categories=categories,\\n items=items,\\n current_category_id=category_id)\",\n \"def show_category(update, context):\\n query = update.callback_query\\n bot = context.bot\\n # loads json received from callback_data into dictionary\\n ids = json.loads(query.data)\\n category_id = ids['category_id']\\n keyboard = []\\n\\n products = menu[category_id]['products']\\n # iterates over all products in selected category\\n for product_id in products.keys():\\n product = products[product_id]\\n # add each product to keyboard with id information as callback_data\\n keyboard.append([InlineKeyboardButton(product['name'] + \\\" \\\" + product['price'],\\n callback_data=json.dumps({\\\"category_id\\\": category_id,\\n \\\"product_id\\\": product_id}))])\\n\\n reply_markup = InlineKeyboardMarkup(keyboard)\\n # edits last message to keyboard with all products from category\\n bot.edit_message_text(chat_id=query.message.chat_id,\\n message_id=query.message.message_id,\\n text='Select desired food in ' + menu[category_id]['category'] + \\\":\\\",\\n reply_markup=reply_markup)\\n # notify ConversationHandler of THIRD stage\\n return THIRD\",\n \"async def category(self,ctx):\\n await ctx.send(\\\"Yes this is a category.\\\")\",\n \"def showCategories():\\n categories = session.query(Category).order_by(asc(Category.name))\\n return render_template('categories.html', categories=categories)\",\n \"def show_categories():\\n categories = session.query(Category).all()\\n username = login_session.get('username')\\n user_id = login_session.get('user_id')\\n provider = login_session.get('provider')\\n if username is not None:\\n username = login_session.get('username')\\n return render_template(\\\"categories.html\\\", categories=categories,\\n username=username, user_id=user_id,\\n provider=provider)\",\n \"def showCategoryDetails(cat_id):\\n\\n category = Category.query.get(cat_id)\\n # get all the poses under that category\\n all_poses = db.session.query(Pose).join(PoseCategory).filter(PoseCategory.cat_id==cat_id).all()\\n\\n return render_template(\\\"category-details.html\\\", all_poses=all_poses, category=category)\",\n \"def category(request, category_id, template_name='doppler/shift/catalog/category.haml'):\\n category = get_object_or_404(Category, pk=category_id, enabled=True)\\n products = category.enabled_products\\n subcategories = category.children.filter(enabled=True)\\n return render_to_response(\\n template_name,\\n {\\n 'category': category,\\n 'products': products,\\n 'subcategories': subcategories,\\n },\\n context_instance=RequestContext(request))\",\n \"def items_for_category(category_id):\\n items_under_category = session.query(\\n Item).filter_by(category_id=category_id).all()\\n all_categories = session.query(Category).all()\\n category = get_category_in_list(category_id, all_categories)\\n return render_template(\\n 'views/items.html',\\n items=items_under_category,\\n current_category=category,\\n categories=all_categories)\",\n \"def test_view_category_by_id(self):\\n rv = self.client().post('/categories/', data=self.category)\\n self.assertEqual(rv.status_code, 201)\\n result_in_json = json.loads(rv.data.decode('utf-8').replace(\\\"'\\\", \\\"\\\\\\\"\\\"))\\n result = self.client().get(\\n '/categories/{}'.format(result_in_json['category_name']))\\n self.assertEqual(result.status_code, 200)\\n self.assertIn('Stews', str(result.data))\",\n \"def showCategories():\\n\\n categories = session.query(Category).order_by(asc(Category.name))\\n if 'user_id' in login_session:\\n return render_template('categories.html',\\n categories=categories,\\n user=getUserInfo(login_session['user_id']))\\n else:\\n return render_template('pubcategories.html', categories=categories)\",\n \"def show_category_specialist():\\n\\n categories = Category.query.order_by(Category.id.asc())\\n specialists = Specialist.query.order_by(Specialist.id.asc())\\n return render_template('general/category_specialist.html', title='Categories-Specialists', \\n categories=categories, specialists=specialists)\",\n \"def category(request, category):\\n \\n # query for all active listings in selected category\\n auctions = Auction_listing.objects.filter(category=category, active=True)\\n current_bid = Auction_listing.objects.annotate(max_bid=Max('bid__bid'))\\n \\n return render(request, 'auctions/category.html', {\\n 'auctions': auctions,\\n 'category': category,\\n \\\"current_bid\\\": current_bid\\n })\",\n \"def create_item_page():\\n catagories = [c.name for c in Catagory.fetch_all()]\\n return render_template('add_item.html', catagories=catagories, values={})\",\n \"def showCategories():\\r\\n categories = session.query(Category).all()\\r\\n if 'username' not in login_session:\\r\\n return render_template(\\\"publicCategories.html\\\", categories=categories)\\r\\n return render_template(\\\"categories.html\\\", categories=categories)\",\n \"def faqitem_show(request,item_container):\\n app_name = 'faqitem'\\n parent = item_container.get_parent()\\n if parent.item.has_comments:\\n comments = item_comment(request, item_container=item_container)\\n else:\\n comments = ''\\n vars = get_item_vars_show(request, item_container, app_name)\\n vars['comments'] = comments\\n return render_to_response ( 'app/faqitem/base-item.html', vars )\",\n \"def get_item(self, item_id: int, category: str = None):\\n if category:\\n # ensuring that it will be in lowercase\\n category = category.lower()\\n\\n if not category or not category in self.item_categories:\\n # Assuming that if category isnt set, we are searching for anime\\n category = \\\"anime\\\"\\n\\n search_url = f\\\"{SITE_URL}/{self.item_categories[category]}/{item_id}\\\"\\n\\n return self.fetch_url(search_url)\",\n \"def show_categories(self):\\n cat_model = TreeModel(('Categories', ))\\n self.categoriesView.setModel(cat_model)\\n\\n categories = self.orm.fetch_parents()\\n for category in categories:\\n item = TreeItem(category, cat_model.rootItem)\\n cat_model.rootItem.appendChild(item)\\n\\n subs = self.orm.fetch_subcategories_for_parent(category)\\n\\n for sub in subs:\\n sub_item = TreeItem(sub, item)\\n item.appendChild(sub_item)\\n\\n self.categoriesView.expandAll()\",\n \"def cat_details(cat_id, shelter_id):\\n\\n shelter = petfinder.shelter_data_map(shelter_id)\\n shelter = list(shelter.values())\\n cat = petfinder.cat_data_map(cat_id)\\n cat = list(cat.values())\\n\\n return render_template('more_details.html',\\n shelter=shelter,\\n cat=cat)\\n\\n #if user selects <3 to favorite a cat then redirct to the login page\",\n \"def category(request):\\r\\n\\tcategory = request.GET.get('category')\\r\\n\\tgames = Game.objects.filter(category=category)\\r\\n\\treturn render(request, 'home.html', {'games': games, 'MEDIA_URL': settings.MEDIA_URL})\",\n \"def render_item_page(self, client_id, state, user_id, user_name, item_id):\\r\\n item = self._db_manager.get_item(item_id)\\r\\n if item is None:\\r\\n flash(\\\"Invalid item.\\\")\\r\\n return\\r\\n category = self._db_manager.get_category(item[\\\"category_id\\\"])\\r\\n if category is None:\\r\\n # this should not happen unless there is a concurrent delete\\r\\n flash(\\\"Sorry, something went wrong.\\\")\\r\\n return\\r\\n return render_template(\\r\\n \\\"item_view.html\\\",\\r\\n client_id=client_id,\\r\\n state=state,\\r\\n is_logged_in=user_id is not None,\\r\\n is_creator=item[\\\"user_id\\\"] == user_id,\\r\\n user_name=user_name,\\r\\n category=category,\\r\\n item=item\\r\\n )\",\n \"def render_add_item_page(\\r\\n self, client_id, state, user_id, user_name, category_id):\\r\\n categories = self._db_manager.get_category_list(user_id)\\r\\n if len(categories) == 0:\\r\\n flash(\\\"You have created no categories to add items to.\\\")\\r\\n return\\r\\n return render_template(\\r\\n \\\"item_add.html\\\",\\r\\n client_id=client_id,\\r\\n state=state,\\r\\n is_logged_in=True,\\r\\n user_name=user_name,\\r\\n category_id=category_id,\\r\\n categories=categories\\r\\n )\",\n \"def info(self, categories=()):\\n pp = pprint.PrettyPrinter(indent=4)\\n print_text_box('Category')\\n data = self.manager.data[\\\"category\\\"]\\n if any(categories):\\n data = self._get_filtered_category_data(data, categories)\\n pp.pprint(data)\\n print('')\",\n \"def __str__(self):\\n return self.category_name\",\n \"def categories(request, pk):\\n if Category.objects.filter(item_type_id=pk).exists(): # Checks if product_category exists with given id.\\n all_categories = Category.objects.filter(item_type_id=pk)\\n else:\\n return Response(messages.CATEGORY_ITEM_DOES_NOT_EXIST, status=status.HTTP_404_NOT_FOUND)\\n if request.method == 'GET':\\n category_serializer = CategorySerializer(all_categories, many=True)\\n\\n return Response(category_serializer.data[::-1], status=status.HTTP_200_OK)\",\n \"def show_item(self, show_item):\\n\\n self._show_item = show_item\",\n \"def CategoryView(request, cats):\\r\\n\\r\\n context = {\\r\\n 'posts': Post.objects.filter(category=cats.replace('-', ' ')).all(),\\r\\n 'cats': cats,\\r\\n 'cat_menu': Category.objects.all()\\r\\n }\\r\\n return render(request, 'blog/categories.html', context)\",\n \"def display_by_category(request, category):\\n if request.method == \\\"POST\\\":\\n form = SearchForm(request.POST)\\n if form.is_valid():\\n products = AuctionListing.objects.filter(buyer=None).filter(\\n category__iexact=category).filter(title__icontains=form.cleaned_data[\\\"query\\\"])\\n else:\\n products = AuctionListing.objects.filter(buyer=None).filter(\\n category__iexact=category)\\n else:\\n products = AuctionListing.objects.filter(buyer=None).filter(\\n category__iexact=category)\\n form = None\\n bids = []\\n for product in products:\\n bid = product.bids.all().aggregate(Max(\\\"bid\\\")).get(\\\"bid__max\\\")\\n bids.append(bid)\\n return render(request, \\\"auctions/index.html\\\", {\\n \\\"zip_products_bids\\\": zip(products, bids),\\n \\\"category\\\": category,\\n \\\"form\\\": form,\\n \\\"title\\\": \\\"Active Listing\\\",\\n })\",\n \"def show_item_json(category, item):\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n item = (session.query(Items)\\n .filter_by(name=item.replace('-', ' '))\\n .one())\\n return jsonify(item=[item.serialize])\",\n \"def show_category_json(category):\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n category_items = (session.query(Items)\\n .filter_by(category_id=category.id)\\n .order_by(Items.name)\\n .all())\\n return jsonify(category=[category.serialize],\\n items=([category_items.serialize\\n for category_items in category_items]))\",\n \"def categories_menu():\\n categories = ['EU-affairs', 'Economy', 'Security', 'Society', 'World']\\n\\n for category in categories:\\n url = build_url({'mode': 'Topic', 'foldername': category, 'page': 1})\\n li = xbmcgui.ListItem(category, iconImage='DefaultFolder.png')\\n xbmcplugin.addDirectoryItem(handle=ADDON_HANDLE, url=url, listitem=li, isFolder=True)\\n\\n xbmcplugin.endOfDirectory(ADDON_HANDLE)\",\n \"def getcatagory(itemID, page=1):\\n\\n if type(itemID) == int:\\n itemID = \\\"%23{0}\\\".format(itemID)\\n\\n return harvest(GET_CATAGORY_URL, itemID, page)\",\n \"def item_detail(request, slug):\\n\\n item = get_object_or_404(Item, slug=slug)\\n\\n context = {\\n 'item': item,\\n }\\n\\n return render(request, 'items/item_detail.html', context)\",\n \"def newItem():\\n if request.method == 'POST':\\n db.createItem(\\n title=request.form['title'],\\n description=request.form['description'],\\n category_id=request.form['category'],\\n user_id=login_session['user_id'])\\n flash(\\\"New catalog item created!\\\", 'success')\\n return redirect(url_for('showCatalog'))\\n return render_template('new_item.html', categories=db.getAllCategories())\",\n \"def read_category_item(category_item_id):\\n item = session.query(CatalogItem).filter_by(id=category_item_id).one()\\n return item\",\n \"def getCategory():\",\n \"def showCatalog(sport_id):\\n\\n sport = session.query(Sport).filter_by(id=sport_id).one()\\n items = session.query(Item).filter_by(sport_id=sport_id).all()\\n return render_template('catalog.html', sport=sport, items=items)\",\n \"def showItemJSON(category_id, item_id):\\r\\n session = DBSession()\\r\\n item = session.query(Item).filter_by(id=item_id).one()\\r\\n return jsonify(Item=item.serialize)\",\n \"def newItem(category_id):\\n editedCategory = session.query(Category). \\\\\\n filter_by(id=category_id).one()\\n if editedCategory.user_id != login_session['user_id']:\\n flash('You are not authorized to edit this Category.\\\\\\n Please create your own Category in order to edit.')\\n return redirect(url_for('showCategory', category_id=category_id))\\n if request.method == 'POST':\\n newItem = Item(\\n name=request.form['name'],\\n description=request.form['description'],\\n price=request.form['price'],\\n category_id=category_id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Item created')\\n return redirect(url_for('showCategory',\\n category_id=category_id))\\n else:\\n return render_template('newItem.html', category_id=category_id)\",\n \"def newListItem(category_id):\\n\\n if 'username' not in login_session:\\n return redirect('/login')\\n\\n category = session.query(Category).filter_by(id=category_id).one()\\n\\n if category.user_id != login_session['user_id']:\\n flash('You are not the creator of %s category, and cannot modify it' %\\n category.name)\\n return redirect(url_for('showItems', category_id=category.id))\\n if request.method == 'POST':\\n if \\\"btn_new\\\" in request.form:\\n newItem = ListItem(name=request.form['name'],\\n description=request.form['description'],\\n category_id=category_id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Catalog Item: %s Successfully Created' % (newItem.name))\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return render_template('newitem.html',\\n category_id=category_id,\\n user=getUserInfo(login_session['user_id']))\",\n \"def food_item(request, food_id):\\n\\n food = get_object_or_404(Nutrition, pk=food_id)\\n\\n context = {\\n 'food': food,\\n }\\n\\n return render(request, 'nutrition/food.html', context)\",\n \"def category_details_url(id):\\n return reverse('category:category-detail', args=[id])\",\n \"def show_categories():\\n for category in NEWS_CATEGORIES:\\n print(category)\",\n \"def update_item_page(item_name, catagory_name):\\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\\n catagories = [c.name for c in Catagory.fetch_all()]\\n return render_template(\\n 'edit_item.html',\\n catagories=catagories,\\n values={\\n 'name': item.name,\\n 'catagory': item.catagory_name,\\n 'description': item.description\\n },\\n )\",\n \"def __repr__(self):\\n return f\\\"Category=(id={self.id},category_name={self.category_name},category_slug={self.category_slug})\\\"\",\n \"def test_get_item_by_id(self):\\n response = self.client.get('/api/v1/category/1',\\n headers=self.attendant_headers)\\n self.assertEqual(response.status_code, 200)\",\n \"def __str__(self):\\n \\n return \\\"Category ID: %s %s\\\" % (self.category_id, self.name)\",\n \"def retrieve(self, request, pk=None):\\n try:\\n category = ItemCategory.objects.get(pk=pk)\\n serializer = ItemCategorySerializer(category, context={'request': request})\\n return Response(serializer.data)\\n except Exception as ex:\\n return HttpResponseServerError(ex)\",\n \"def category(self):\\n return self._ctx.get(\\\"name\\\", self._ctx[\\\"id\\\"])\",\n \"def edit_item_details(item_id):\\n category_id = None\\n if 'category_id' in request.args:\\n category_id = int(request.args['category_id'])\\n if 'userid' not in login_session:\\n flash('Unfortunately you need to be logged in to make changes', 'error')\\n return redirect(url_for('show_homepage'))\\n\\n item = None\\n if item_id != 0:\\n item = is_user_the_creator(item_id)\\n if request.method == 'GET':\\n categories = session.query(Category).order_by(asc(Category.name)).all()\\n return display_item(categories, item, item_id, category_id)\\n else:\\n return save_item(item, item_id)\",\n \"def browse_category(request):\\n\\n result = {'categories':[], 'products':[]}\\n\\n u = request.user\\n\\n page = request.POST.get('page', 1)\\n\\n cat = Category.objects.get(id=request.POST['cat_id'])\\n if cat.children.count() > 0:\\n result['categories'] = [c.get_json() for c in cat.children.all()]\\n else:\\n # display items\\n result = Product.objects.filter_category(cat.category_id, page, u) \\n\\n return JSONHttpResponse(result)\",\n \"def editItem(category_item_id):\\n editedItem = db.findItem(id=category_item_id)\\n if editedItem.user_id != login_session['user_id']:\\n return not_authorized()\\n if request.method == 'POST':\\n db.updateItem(editedItem, request.form)\\n return redirect(url_for('showCatalog'))\\n return render_template(\\n 'edit_item.html', categories=db.getAllCategories(), item=editedItem)\",\n \"def category_view(slug, page):\\n board_id = h.get_board_id()\\n user = g.user\\n\\n h.require_board_access(board_id, user.id)\\n\\n category = board_category_query_service.find_category_by_slug(\\n board_id, slug\\n )\\n\\n if category is None:\\n abort(404)\\n\\n if category.hidden:\\n abort(404)\\n\\n if user.authenticated:\\n board_last_view_service.mark_category_as_just_viewed(\\n category.id, user.id\\n )\\n\\n include_hidden = service.may_current_user_view_hidden()\\n topics_per_page = service.get_topics_per_page_value()\\n\\n topics = board_topic_query_service.paginate_topics_of_category(\\n category.id, page, topics_per_page, include_hidden=include_hidden\\n )\\n\\n service.add_topic_creators(topics.items)\\n service.add_topic_unseen_flag(topics.items, user)\\n\\n return {\\n 'category': category,\\n 'topics': topics,\\n }\",\n \"def newItem(category_id):\\n category = session.query(Category).filter_by(id=category_id).one()\\n if request.method == 'POST':\\n newItem = Item(name=request.form['name'],\\n description=request.form['description'],\\n price=request.form['price'], category_id=category.id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Item %s Successfully Created' % (newItem.name))\\n return redirect(url_for('showItem', category_id=category.id))\\n else:\\n return render_template('newitem.html', category_id=category.id)\",\n \"def show_categories(update, context):\\n query = update.callback_query\\n bot = context.bot\\n\\n keyboard = []\\n # iterate over every category\\n for category_id in menu.keys():\\n # add category to keyboard\\n keyboard.append([InlineKeyboardButton(str(menu[category_id]['category']),\\n callback_data=json.dumps({\\\"category_id\\\": category_id,\\n \\\"product_id\\\": 0}))])\\n\\n reply_markup = InlineKeyboardMarkup(keyboard)\\n\\n # edits last message to keyboard with all categories\\n bot.edit_message_text(chat_id=query.message.chat_id,\\n message_id=query.message.message_id,\\n text='Please choose :',\\n reply_markup=reply_markup)\\n # notify ConversationHandler of SECOND stage\\n return SECOND\",\n \"def read_item(item_name, catagory_name):\\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\\n return render_template('item.html', item=item)\",\n \"def category_view(slug, page):\\n board_id = h.get_board_id()\\n user = g.user\\n\\n h.require_board_access(board_id, user.id)\\n\\n category = board_category_query_service.find_category_by_slug(\\n board_id, slug\\n )\\n\\n if category is None:\\n abort(404)\\n\\n if category.hidden:\\n abort(404)\\n\\n if user.authenticated:\\n board_last_view_service.mark_category_as_just_viewed(\\n category.id, user.id\\n )\\n\\n include_hidden = service.may_current_user_view_hidden()\\n topics_per_page = service.get_topics_per_page_value()\\n\\n topics = board_topic_query_service.paginate_topics_of_category(\\n category.id, include_hidden, page, topics_per_page\\n )\\n\\n service.add_topic_creators(topics.items)\\n service.add_topic_unseen_flag(topics.items, user)\\n\\n return {\\n 'category': category,\\n 'topics': topics,\\n }\",\n \"def render_edit_category_page(\\r\\n self, client_id, state, user_id, user_name, category_id):\\r\\n category = self._db_manager.get_category(category_id)\\r\\n if category is None:\\r\\n flash(\\\"Invalid category.\\\")\\r\\n return\\r\\n if category[\\\"user_id\\\"] != user_id:\\r\\n # the check whether the user owns the category can only be made\\r\\n # here since the database needs to be consulted\\r\\n flash(\\\"Only the original creator can edit a category.\\\")\\r\\n return\\r\\n return render_template(\\r\\n \\\"category_edit.html\\\",\\r\\n client_id=client_id,\\r\\n state=state,\\r\\n is_logged_in=True,\\r\\n user_name=user_name,\\r\\n category=category\\r\\n )\",\n \"def __str__(self):\\n return self.cat_name\",\n \"def items(request, pk):\\n\\n if Item.objects.filter(category_id=pk).exists(): # Checks if product_category exists with given id.\\n all_items = Item.objects.filter(category_id=pk)\\n else:\\n return Response(messages.ITEMS_DOES_NOT_EXIST, status=status.HTTP_404_NOT_FOUND)\\n if request.method == 'GET':\\n item_serializer = ItemSerializer(all_items, many=True)\\n return Response(item_serializer.data[::-1], status=status.HTTP_200_OK)\",\n \"def new_item():\\n if request.method == 'POST':\\n new_item = Item(\\n category_id=int(request.form['category']),\\n name=request.form['name'],\\n description=request.form['description'],\\n created_date=datetime.datetime.now(),\\n user_id=login_session['user_id'])\\n session.add(new_item)\\n session.commit()\\n return redirect(\\n url_for(\\n 'item_details',\\n category_id=new_item.category_id,\\n item_id=new_item.id))\\n else:\\n categories = session.query(\\n Category).all()\\n return render_template(\\n 'views/add.html',\\n categories=categories)\",\n \"def category(self, category: str):\\n\\n self._category = category\",\n \"def deleteCategory(category_id):\\n editedCategory = session.query(Category).\\\\\\n filter_by(id=category_id).one()\\n editedItem = session.query(Item).\\\\\\n filter_by(category_id=editedCategory.id).all()\\n print editedItem\\n if editedCategory.user_id != login_session['user_id']:\\n flash('You are not authorized to delete this Item.\\\\\\n Please create own Category with items in order to \\\\\\n delete items.')\\n return redirect(url_for('showallCategories'))\\n else:\\n if editedItem:\\n flash('Category Deletion not possible. \\\\\\n Please delete the items in Category')\\n return redirect(url_for('showCategory',\\n category_id=category_id))\\n elif request.method == 'POST':\\n session.delete(editedCategory)\\n session.commit()\\n flash('Category Deletion successfull')\\n return redirect(url_for('showallCategories'))\\n else:\\n return render_template(\\n 'deleteCategory.html', category_id=category_id,\\n category=editedCategory)\",\n \"def viewItem(sport_id, item_id):\\n\\n sport = session.query(Sport).filter_by(id=sport_id).one()\\n item = session.query(Item).filter_by(id=item_id).one()\\n return render_template('viewitem.html', sport_id=sport_id, item_id=item_id,\\n item=item, sport=sport)\",\n \"async def cat(self, ctx):\\n async with ctx.session.get('https://api.thecatapi.com/v1/images/search') as resp:\\n if resp.status != 200:\\n return await ctx.send('No cat found :(')\\n js = await resp.json()\\n await ctx.send(embed=discord.Embed(title='Random Cat').set_image(url=js[0]['url']))\",\n \"def view_item(request, product_id):\\n\\n sizes = None\\n forsixes = None\\n back_to_cats = None\\n\\n product = get_object_or_404(Product, pk=product_id)\\n reviews = Review.objects.filter(product=product).order_by('-date_posted')\\n\\n if product.is_sizes:\\n try:\\n sizes = Size.objects.get(name=product.name)\\n except Size.DoesNotExist:\\n messages.info(request, (\\n \\\"This item has only one size\\\")\\n )\\n\\n if product.is_for_six:\\n try:\\n forsixes = Forsix.objects.get(name=product.name)\\n except Forsix.DoesNotExist:\\n messages.info(request, (\\n \\\"This item has only one size\\\")\\n )\\n\\n if 'r' in request.GET:\\n back_to_cats = request.GET['r']\\n print(back_to_cats)\\n\\n context = {\\n 'product': product,\\n 'reviews': reviews,\\n 'sizes': sizes,\\n 'forsixes': forsixes,\\n 'back_to_cats': back_to_cats\\n }\\n\\n return render(request, 'products/view_item.html', context)\",\n \"def delete_item_page(item_name, catagory_name):\\n return render_template(\\n 'delete_item.html', item_name=item_name, catagory_name=catagory_name\\n )\",\n \"def show_item_by_id(plugin, item_id):\\n import alltheitems.item_page\\n return alltheitems.item_page.item_page(plugin + ':' + item_id)\",\n \"def edit_item(category, item):\\n # Verify user login. If not, redirect to login page.\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n else:\\n flash('Please log in.')\\n return redirect(url_for('home'))\\n # Query database with SQLAlchemy to display categories on page\\n categories = session.query(Categories).all()\\n if request.method == 'POST':\\n # Query database with SQLAlchemy and store queries as objects\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n item = (session.query(Items)\\n .filter_by(name=item.replace('-', ' '))\\n .one())\\n # Get form fields submitted by user, or retain item info\\n name = request.form['name'] if request.form['name'] else item.name\\n url = request.form['url'] if request.form['url'] else item.url\\n if request.form['photo_url']:\\n photo_url = request.form['photo_url']\\n else:\\n photo_url = item.photo_url\\n if request.form['description']:\\n description = request.form['description']\\n else:\\n description = item.description\\n category = request.form['item_category']\\n # Retrieve the database ID of the item's category\\n category_id = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n # Get user's database ID\\n user_db_id = (session.query(Users)\\n .filter_by(email=login_session['email'])\\n .one()).id\\n # Get database ID of creator\\n creator_db_id = item.creator_db_id\\n print(\\\"Current user's database primary key id is {}.\\\"\\n .format(user_db_id))\\n print(\\\"Item creator's database primary key id is {}.\\\"\\n .format(creator_db_id))\\n print('Item to edit is \\\"{}\\\".'.format(item.name))\\n # Only allow creator to edit. If not, redirect to login.\\n if user_db_id != creator_db_id:\\n flash('Only the creator can edit. Please log in as creator.')\\n return redirect(url_for('home'))\\n # Store edits in an object\\n edited_item = Items(name=name,\\n url=url,\\n photo_url=photo_url,\\n description=description,\\n category_id=category_id.id,\\n creator_db_id=user_db_id)\\n # Overwrite item object with new info from edited_item object\\n item.name = edited_item.name\\n item.url = edited_item.url\\n item.photo_url = edited_item.photo_url\\n item.description = edited_item.description\\n item.category_id = edited_item.category_id\\n session.add(item)\\n session.commit()\\n print('Item \\\"{}\\\" edited.'.format(edited_item.name))\\n # Return to homepage\\n return redirect(url_for('home'))\\n else:\\n # Query database with SQLAlchemy to display categories on page\\n categories = session.query(Categories).all()\\n # Render webpage\\n return render_template('edit_item.html',\\n categories=categories,\\n item=item,\\n login_status=login_status)\",\n \"def test_view_categories(self):\\n res = self.client().post('/categories/', data=self.category)\\n self.assertEqual(res.status_code, 201)\\n res = self.client().get('/categories/')\\n self.assertEqual(res.status_code, 200)\\n self.assertIn('Stews', str(res.data))\",\n \"def category(self) -> str:\\n return pulumi.get(self, \\\"category\\\")\",\n \"def catalog():\\n session['target'] = \\\"/\\\"\\n sqlsession = SQLSESSION()\\n items = sqlsession.query(Item, Category)\\\\\\n .join(Category).order_by(Item.create_date).limit(10)\\n categories = sqlsession.query(Category).all()\\n return render_template(\\\"catalog.html\\\",\\n items=items,\\n categories=categories,\\n item_title=\\\"Latest Items\\\")\",\n \"def test_get_a_category(self):\\n self.test_add_category_success()\\n response = self.client.get('/categories/1',\\n headers={\\\"Authorization\\\": self.token})\\n self.assertEqual(response.status_code, 200)\\n self.assertIn('asian', response.data.decode())\",\n \"def category_index(request, slug_category):\\n selected_category = get_object_or_404(Category, slug=slug_category)\\n category_entries = selected_category.entry_set.filter(status=2).order_by('-pub_date')\\n paginator = Paginator(category_entries, 4)#4 posts/page\\n try:\\n page = int(request.GET.get('page', '1'))\\n except ValueError:\\n page = 1\\n try:\\n entries = paginator.page(page)\\n except (EmptyPage, InvalidPage):\\n entries = paginator.page(paginator.num_pages)\\n return render_to_response('blog/category_index.html', {'entries':entries, 'category':selected_category}, RequestContext(request))\",\n \"def getcategory(self):\\n\\n response = requests.get(\\\"https://fr.openfoodfacts.org/categories.json\\\")\\n\\n data = response.json()\\n\\n self.rawcategorydata = data\",\n \"def createItem(category_id):\\r\\n if 'username' not in login_session:\\r\\n return redirect(url_for('showLogin'))\\r\\n if request.method == 'POST':\\r\\n session = DBSession()\\r\\n item = Item(name=request.form['name'],\\r\\n description=request.form['description'],\\r\\n category_id=category_id,\\r\\n user_id=login_session['user_id'])\\r\\n session.add(item)\\r\\n session.commit()\\r\\n return redirect(url_for('showCategoryItems', category_id=category_id))\\r\\n else:\\r\\n return render_template('newitem.html', category_id=category_id)\",\n \"def showallCategories():\\n category = session.query(Category).all()\\n onedayearly = datetime.timedelta(hours=24)\\n since = datetime.datetime.now() - onedayearly\\n latest = session.query(Item).filter(Item.date > since)\\n return render_template('category.html', category=category, latest=latest)\",\n \"def get_category(self) -> str:\\n return self.category\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79654604","0.7739004","0.7643676","0.7522781","0.7224209","0.702118","0.7007901","0.69838154","0.6969686","0.68813515","0.67284054","0.6714985","0.67128104","0.6640791","0.65600896","0.6559297","0.65177655","0.6493208","0.6447697","0.6445132","0.6391688","0.63806367","0.6373013","0.63603246","0.6285808","0.6166651","0.61424804","0.61104655","0.60680586","0.60586","0.60510355","0.6033211","0.6015909","0.5997748","0.59973866","0.59804285","0.5979193","0.59790415","0.5953388","0.5928331","0.5917345","0.5914209","0.58891857","0.5886969","0.58803535","0.5874652","0.5868125","0.58376616","0.5830528","0.58252805","0.5795153","0.57728034","0.5770564","0.57361096","0.57198465","0.56871665","0.5685791","0.5675782","0.5669449","0.5657384","0.56518084","0.5643044","0.56398773","0.5627696","0.5607849","0.5597892","0.5597661","0.55904704","0.55561084","0.55543715","0.55449426","0.5540252","0.5530216","0.549304","0.5492902","0.54901654","0.5488732","0.54864794","0.5485597","0.5473248","0.54707515","0.547003","0.5457305","0.54550636","0.5445465","0.54303867","0.54282135","0.5418318","0.5415304","0.5415169","0.54117996","0.54115677","0.541028","0.5394371","0.5368959","0.5364582","0.53570086","0.535694","0.53444046","0.533908"],"string":"[\n \"0.79654604\",\n \"0.7739004\",\n \"0.7643676\",\n \"0.7522781\",\n \"0.7224209\",\n \"0.702118\",\n \"0.7007901\",\n \"0.69838154\",\n \"0.6969686\",\n \"0.68813515\",\n \"0.67284054\",\n \"0.6714985\",\n \"0.67128104\",\n \"0.6640791\",\n \"0.65600896\",\n \"0.6559297\",\n \"0.65177655\",\n \"0.6493208\",\n \"0.6447697\",\n \"0.6445132\",\n \"0.6391688\",\n \"0.63806367\",\n \"0.6373013\",\n \"0.63603246\",\n \"0.6285808\",\n \"0.6166651\",\n \"0.61424804\",\n \"0.61104655\",\n \"0.60680586\",\n \"0.60586\",\n \"0.60510355\",\n \"0.6033211\",\n \"0.6015909\",\n \"0.5997748\",\n \"0.59973866\",\n \"0.59804285\",\n \"0.5979193\",\n \"0.59790415\",\n \"0.5953388\",\n \"0.5928331\",\n \"0.5917345\",\n \"0.5914209\",\n \"0.58891857\",\n \"0.5886969\",\n \"0.58803535\",\n \"0.5874652\",\n \"0.5868125\",\n \"0.58376616\",\n \"0.5830528\",\n \"0.58252805\",\n \"0.5795153\",\n \"0.57728034\",\n \"0.5770564\",\n \"0.57361096\",\n \"0.57198465\",\n \"0.56871665\",\n \"0.5685791\",\n \"0.5675782\",\n \"0.5669449\",\n \"0.5657384\",\n \"0.56518084\",\n \"0.5643044\",\n \"0.56398773\",\n \"0.5627696\",\n \"0.5607849\",\n \"0.5597892\",\n \"0.5597661\",\n \"0.55904704\",\n \"0.55561084\",\n \"0.55543715\",\n \"0.55449426\",\n \"0.5540252\",\n \"0.5530216\",\n \"0.549304\",\n \"0.5492902\",\n \"0.54901654\",\n \"0.5488732\",\n \"0.54864794\",\n \"0.5485597\",\n \"0.5473248\",\n \"0.54707515\",\n \"0.547003\",\n \"0.5457305\",\n \"0.54550636\",\n \"0.5445465\",\n \"0.54303867\",\n \"0.54282135\",\n \"0.5418318\",\n \"0.5415304\",\n \"0.5415169\",\n \"0.54117996\",\n \"0.54115677\",\n \"0.541028\",\n \"0.5394371\",\n \"0.5368959\",\n \"0.5364582\",\n \"0.53570086\",\n \"0.535694\",\n \"0.53444046\",\n \"0.533908\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7802788"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14888,"cells":{"query":{"kind":"string","value":"Allow user to create new catalog item"},"document":{"kind":"string","value":"def newItem():\n if request.method == 'POST':\n db.createItem(\n title=request.form['title'],\n description=request.form['description'],\n category_id=request.form['category'],\n user_id=login_session['user_id'])\n flash(\"New catalog item created!\", 'success')\n return redirect(url_for('showCatalog'))\n return render_template('new_item.html', categories=db.getAllCategories())"},"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_item(self, user: User, **kwargs) -> None:","def addCatalogItem(sport_id):\n\n sport = session.query(Sport).filter_by(id=sport_id).one()\n if request.method == 'POST':\n newCatalogItem = Item(\n name=request.form['itemName'],\n description=request.form['itemDescription'],\n sport_id=sport_id,\n user_id=login_session['user_id'])\n session.add(newCatalogItem)\n session.commit()\n return redirect(url_for('showCatalog', sport_id=sport_id))\n else:\n return render_template('newcatalogitem.html', sport_id=sport_id)","def create_item():\n name = request.form['name']\n catagory = request.form['catagory']\n description = request.form['description']\n errors = form_errors(request.form)\n if errors:\n catagories = [c.name for c in Catagory.fetch_all()]\n values = {\n 'name': name, 'catagory': catagory, 'description': description\n }\n return render_template(\n 'add_item.html',\n catagories=catagories,\n values=values,\n errors=errors\n )\n Item.create(name, catagory_name=catagory, description=description)\n return redirect(url_for(\n 'read_item', catagory_name=catagory, item_name=name\n ))","def createItem(category_id):\r\n if 'username' not in login_session:\r\n return redirect(url_for('showLogin'))\r\n if request.method == 'POST':\r\n session = DBSession()\r\n item = Item(name=request.form['name'],\r\n description=request.form['description'],\r\n category_id=category_id,\r\n user_id=login_session['user_id'])\r\n session.add(item)\r\n session.commit()\r\n return redirect(url_for('showCategoryItems', category_id=category_id))\r\n else:\r\n return render_template('newitem.html', category_id=category_id)","def new_item():\n if request.method == 'POST':\n new_item = Item(\n category_id=int(request.form['category']),\n name=request.form['name'],\n description=request.form['description'],\n created_date=datetime.datetime.now(),\n user_id=login_session['user_id'])\n session.add(new_item)\n session.commit()\n return redirect(\n url_for(\n 'item_details',\n category_id=new_item.category_id,\n item_id=new_item.id))\n else:\n categories = session.query(\n Category).all()\n return render_template(\n 'views/add.html',\n categories=categories)","def newListItem(category_id):\n\n if 'username' not in login_session:\n return redirect('/login')\n\n category = session.query(Category).filter_by(id=category_id).one()\n\n if category.user_id != login_session['user_id']:\n flash('You are not the creator of %s category, and cannot modify it' %\n category.name)\n return redirect(url_for('showItems', category_id=category.id))\n if request.method == 'POST':\n if \"btn_new\" in request.form:\n newItem = ListItem(name=request.form['name'],\n description=request.form['description'],\n category_id=category_id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Catalog Item: %s Successfully Created' % (newItem.name))\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return render_template('newitem.html',\n category_id=category_id,\n user=getUserInfo(login_session['user_id']))","def test_vault_create_new_vault_item(self):\n pass","def add_item():\n if 'username' not in login_session:\n response = make_response(\n json.dumps({'error': 'User is logged out. This should not happen'}), 401\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n try:\n if request.method == 'POST':\n item = Item()\n # First we populate the new item.\n item.category_id = request.form['categoryId']\n item.picture = request.form['picture']\n item.name = request.form['name']\n item.price = request.form['price']\n item.description = request.form['description']\n item.user_id = login_session['user_id']\n # Now let's pull its category.\n category = session.query(Category).filter_by(id=item.category_id).one()\n # And make sure they're properly linked.\n item.category = category\n session.add(item)\n session.flush()\n id = item.id\n session.commit()\n response = make_response(\n json.dumps({'success': '', 'nonce': login_session['state'], 'id': id}), 200\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n except Exception as inst:\n print(type(inst))\n print(inst.args)\n print(inst)","def insert_item():\n if 'userinfo' not in session.keys():\n session['target'] = url_for('insert_item')\n return redirect(url_for('gconnect'))\n if request.method == 'POST':\n creator_email = session['userinfo']['email']\n sqlsession = SQLSESSION()\n user = sqlsession.query(User).filter_by(email=creator_email).first()\n item = Item(name=request.form['name'],\n description=request.form['description'],\n category_id=int(request.form['category']),\n creator_id=user.id)\n sqlsession.add(item)\n sqlsession.commit()\n return redirect(\"/\")\n sqlsession = SQLSESSION()\n categories = sqlsession.query(Category).all()\n return render_template(\"new_item.html\",\n categories=categories)","def newItem(category_id):\n category = session.query(Category).filter_by(id=category_id).one()\n if request.method == 'POST':\n newItem = Item(name=request.form['name'],\n description=request.form['description'],\n price=request.form['price'], category_id=category.id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Item %s Successfully Created' % (newItem.name))\n return redirect(url_for('showItem', category_id=category.id))\n else:\n return render_template('newitem.html', category_id=category.id)","def newItem():\n if request.method == 'POST':\n if not checkLogin():\n return requests(url_for('catelog'))\n\n if request.form['name'].strip() == '':\n flash('item create failed: name is empty!')\n return redirect(url_for('newItem'))\n\n category = session.query(\n Category).filter_by(\n name=request.form['category']).one()\n\n ifCategory = session.query(Category).filter_by(\n name=request.form['category']).one()\n ifItem = session.query(Item).filter_by(\n category_id=ifCategory.id,\n name=request.form['name']).all()\n if (len(ifItem) > 0):\n flash('item create failed: item(%s) \\\n is already exist in category(%s)' % (\n ifItem[0].name,\n ifCategory.name))\n return redirect(url_for('catelog'))\n\n newItem = Item(\n name=request.form['name'],\n description=request.form['description'],\n category=category,\n auth=getLoginUser(),\n time=getIntTime())\n session.add(newItem)\n session.commit()\n\n flash('new item created: %s' % newItem.name)\n\n return redirect(url_for(\n 'itemDetail',\n category_name=category.name,\n item_name=newItem.name))\n else:\n all_category = session.query(Category).all()\n return render_template(\n 'new-item.html',\n all_category=all_category,\n isLogin=checkLogin())","def create_item_page():\n catagories = [c.name for c in Catagory.fetch_all()]\n return render_template('add_item.html', catagories=catagories, values={})","def insert_item_page(request):\n validate(instance=request.body, schema=item_schema)\n body = json.loads(request.body)\n item = Item.new_item(body['cart_id'], body['food_id'], body['count'])\n return JsonResponse(model_to_json(item))","def new_item():\n form = ItemForm()\n user = current_user\n\n # If the form is validated, add its data to the database\n if form.validate_on_submit():\n\n # Check that an item with the same name and sport does not\n # already exist, or send a flash message and do not add the\n # new item to the database\n query = Item.query.filter_by(name=form.name.data,\n sport=form.sport.data).first()\n if query:\n flash('This sport already has an item with that name.', 'bad')\n\n # If the item does not yet exist, add all details to the\n # database, send a flash message, and redirect to 'home'\n else:\n name = form.name.data\n sport = form.sport.data\n category = form.category.data\n description = form.description.data\n private = form.private.data\n item = Item(name=name, sport=sport, category=category,\n description=description, private=private,\n user_id=user.id)\n db.session.add(item)\n db.session.commit()\n flash(f'\"{name}\" has been added!', 'good')\n return redirect(url_for('main.home'))\n\n return render_template('new_item.html', form=form, title='New Item')","def create_item():\n #if not request.json:\n # abort(400)\n parser = reqparse.RequestParser()\n parser.add_argument('item_code', type=int, required=False, help=\"Item code missing\")\n parser.add_argument('item_name', type=str, required=True, help=\"Item name missing\")\n parser.add_argument('size', type=str, required=True, help=\"Size missing\")\n parser.add_argument('color', type=str, required=True, help=\"Color missing\")\n parser.add_argument('quality', type=str, required=True, help=\"Quality missing\")\n parser.add_argument('username', type=str, required=True, help=\"Username missing\")\n args = parser.parse_args(strict=True)\n user_code = get_user_code(args['username'])\n if user_code is None:\n return make_response(jsonify({'error': 'User does not exists'}), 400)\n new_item = dict(\n item_code = args['item_code'],\n item_name = args['item_name'],\n size_code = get_size_code( args['size']),\n color_code = get_color_code( args['color']),\n quality_code = get_quality_code( args['quality'])\n )\n try:\n u = models.Items(**new_item)\n db.session.add(u)\n db.session.commit()\n except sqlalchemy.exc.IntegrityError, e:\n return make_response(jsonify({'error': 'item code already exists.'}), 400)\n\n return make_response(jsonify({'success': True}))","def add_item():\n\n form = ItemForm()\n # Query for select field\n form.category_id.query = Category.query.filter(\n Category.user_id == current_user.id).all()\n\n if form.validate_on_submit():\n new_item = Item(\n category_id=form.category_id.data.id,\n name=form.name.data.capitalize(),\n description=form.description.data,\n user_id=current_user.id)\n db.session.add(new_item)\n db.session.commit()\n flash(\"New item '{}' was successfully created\".format(\n form.name.data.capitalize()), category='success')\n return redirect(url_for('url.index'))\n\n return render_template(\n 'forms/form.html',\n form_title='Add Item',\n form=form,\n form_name='item',\n action=url_for('url.add_item'))","def add(auth_context):\n print(\"Add\")\n uid = auth_context.get('uid')\n item_id = request.form.get('id')\n if item_id:\n print(\"item_id: \"+item_id)\n carts.add_to_cart(uid,item_id)\n return \"Operation Completed\", 200\n return \"Operation Failed\", 400","def add_item(request):\n if request.user.is_superuser:\n if request.method == \"POST\":\n form = ProductForm(request.POST, request.FILES)\n if form.is_valid():\n new_item = form.save()\n messages.success(request, 'Your product was added to the '\n 'store successfully.')\n return redirect(reverse('item_info', args=[new_item.id]))\n else:\n messages.error(request, 'There was an issue adding the '\n 'product. Please ensure the form is valid.')\n else:\n form = ProductForm()\n else:\n messages.error(request, 'Sorry, you do not have permission to access '\n 'this page.')\n return redirect(reverse('home'))\n\n template = 'shop/add_item.html'\n context = {\n 'form': form,\n }\n\n return render(request, template, context)","def newItem(category_id):\n editedCategory = session.query(Category). \\\n filter_by(id=category_id).one()\n if editedCategory.user_id != login_session['user_id']:\n flash('You are not authorized to edit this Category.\\\n Please create your own Category in order to edit.')\n return redirect(url_for('showCategory', category_id=category_id))\n if request.method == 'POST':\n newItem = Item(\n name=request.form['name'],\n description=request.form['description'],\n price=request.form['price'],\n category_id=category_id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Item created')\n return redirect(url_for('showCategory',\n category_id=category_id))\n else:\n return render_template('newItem.html', category_id=category_id)","def put_on_sale():\n\n item = {\n \"status\": 'for_sale',\n \"category\": request.form['item-type'],\n \"name\": request.form['item-name'],\n \"price\": request.form['item-price'],\n \"description\": request.form['item-description'],\n \"mail\": request.form['seller-email']\n }\n\n put_item(item)\n\n return redirect('/')","def catalog_create(self, args):\n try:\n if args.id and self.server.connect_ermrest(args.id).exists():\n print(\"Catalog already exists\")\n return\n owner = args.owner if args.owner else None\n catalog = self.server.create_ermrest_catalog(args.id, owner)\n if args.auto_configure:\n model = catalog.getCatalogModel()\n model.configure_baseline_catalog(**args.configure_args)\n if not args.quiet:\n print(\"Created new catalog %s with the following default configuration:\\n\" % catalog.catalog_id)\n pp(catalog.get('/').json())\n except HTTPError as e:\n if e.response.status_code == requests.codes.not_found:\n raise ResourceException('Catalog not found', e)\n elif e.response.status_code == requests.codes.conflict:\n raise ResourceException(\"Catalog already exists\", e)\n else:\n raise e","def createNewItem(request):\n newItem = ItemSerializer(data=request.data)\n if newItem.is_valid():\n newItem.save()\n return Response(newItem.data, status=status.HTTP_201_CREATED)\n\n fail = {\n \"item\" : \"item is not valid\"\n }\n return JsonResponse(fail)","def createItem(name, description, category_id, image, user_id):\n i = Item(name=name, description=description, category_id=category_id,\n image=image, user_id=user_id, pub_date=datetime.utcnow())\n db_session.add(i)\n db_session.commit()\n return i","def add_item():\n # Verify user login. If not, redirect to login page.\n login_status = None\n if 'email' in login_session:\n login_status = True\n else:\n flash('Please log in.')\n return redirect(url_for('home'))\n if request.method == 'POST':\n # Get form fields\n name = request.form['name']\n url = request.form['url']\n photo_url = request.form['photo_url']\n description = request.form['description']\n category = request.form['item_category']\n # Retrieve the database ID of the selected category\n category_id = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n # Retrieve user's database ID for the item's database entry\n user_db_id = (session.query(Users)\n .filter_by(email=login_session['email'])\n .one()).id\n print(\"Current user's database primary key id is {}.\"\n .format(user_db_id))\n print('Database ID of category is {}.'.format(category_id.id))\n # Flash messages for incomplete item info\n if not request.form['name']:\n flash('Please add item name')\n return redirect(url_for('add_item'))\n if not request.form['url']:\n flash('Please add item URL')\n return redirect(url_for('add_item'))\n if not request.form['photo_url']:\n flash('Please add item photo URL')\n return redirect(url_for('add_item'))\n if not request.form['description']:\n flash('Please add a description')\n return redirect(url_for('add_item'))\n # Query database for item name\n item_name_in_db = (session.query(Items.name)\n .filter_by(name=name)\n .all())\n # If the item name is already in the database, don't add\n if item_name_in_db:\n print('Item name \"{}\" already in database.'.format(name))\n flash('Item name \"{}\" already in database.'.format(name))\n return redirect(url_for('add_item'))\n # Create object with form field info to add to database\n new_item = Items(name=name,\n url=url,\n photo_url=photo_url,\n description=description,\n category_id=category_id.id,\n creator_db_id=user_db_id)\n session.add(new_item)\n session.commit()\n print('Item \"{}\" created.'.format(new_item.name))\n # Return to homepage\n return redirect(url_for('home'))\n else:\n # Query database with SQLAlchemy to display categories on page\n categories = session.query(Categories).all()\n # Render webpage\n return render_template('add_item.html',\n categories=categories,\n login_status=login_status)","def _create_item(request):\r\n usage_key = UsageKey.from_string(request.json['parent_locator'])\r\n category = request.json['category']\r\n\r\n display_name = request.json.get('display_name')\r\n\r\n if not has_course_access(request.user, usage_key.course_key):\r\n raise PermissionDenied()\r\n\r\n parent = get_modulestore(category).get_item(usage_key)\r\n dest_usage_key = usage_key.replace(category=category, name=uuid4().hex)\r\n\r\n # get the metadata, display_name, and definition from the request\r\n metadata = {}\r\n data = None\r\n template_id = request.json.get('boilerplate')\r\n if template_id:\r\n clz = parent.runtime.load_block_type(category)\r\n if clz is not None:\r\n template = clz.get_template(template_id)\r\n if template is not None:\r\n metadata = template.get('metadata', {})\r\n data = template.get('data')\r\n\r\n if display_name is not None:\r\n metadata['display_name'] = display_name\r\n\r\n get_modulestore(category).create_and_save_xmodule(\r\n dest_usage_key,\r\n definition_data=data,\r\n metadata=metadata,\r\n system=parent.runtime,\r\n )\r\n\r\n # TODO replace w/ nicer accessor\r\n if not 'detached' in parent.runtime.load_block_type(category)._class_tags:\r\n parent.children.append(dest_usage_key)\r\n get_modulestore(parent.location).update_item(parent, request.user.id)\r\n\r\n return JsonResponse({\"locator\": unicode(dest_usage_key), \"courseKey\": unicode(dest_usage_key.course_key)})","def create_item(self, obj):\n logger.info('ItemProduct adding item initiated')\n try:\n with Transaction().start(DBNAME, 1) as transaction:\n unit, = self.ProductUom.search([('name', '=', obj['units'])])\n template = self.ProductTemplate()\n try:\n if self.Product.search([('code', '=', obj['id']), ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]:\n return False\n except Exception:\n pass\n template.category = self.ProductCategory.search([('name', '=', obj['category'])])[-1]\n template.default_uom = unit\n template.purchase_uom = unit\n template.type = 'goods'\n rate = Decimal(obj['rate'])\n cost = rate / 2\n template.name = obj['name']\n template.list_price = Decimal(rate)\n template.cost_price = Decimal(cost)\n template.purchasable = True\n template.account_expense = self.accounts['expense']\n template.account_receivable = self.accounts['receivable']\n template.save()\n # transaction.cursor.commit()\n product = self.Product()\n product.template = template\n product.code = obj['id']\n product.description = 'Stock'\n product.save()\n transaction.cursor.commit()\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False","def _create_item(self, parent_location, category, display_name, **kwargs):\n return ItemFactory.create(\n parent_location=parent_location,\n category=category,\n display_name=display_name,\n publish_item=False,\n user_id=self.user.id,\n **kwargs\n )","def add_new_item(self, request, *a, **kw):\n item_def = request.data\n cpdoc = self.get_object()\n item_def['calendar_plan'] = cpdoc.id\n\n item_ser = self.get_serializer(data=item_def)\n item_ser.is_valid(raise_exception=True)\n item_obj = item_ser.save()\n\n headers = self.get_success_headers(item_ser.data)\n return response.Response(item_ser.data, headers=headers)","def create_item_command(cog_href: str, destination: str) -> None:\n item = stac.create_item(cog_href)\n\n item.save_object(dest_href=destination)","def new(self, *args, **kw):\n id_tipo_item = UrlParser.parse_id(request.url, \"tipositems\")\n url_action = \"./\"\n\n pp = PoseePermiso('redefinir tipo item', id_tipo_item=id_tipo_item)\n if not pp.is_met(request.environ):\n flash(pp.message % pp.nombre_permiso, 'warning')\n redirect(atras)\n tmpl_context.widget = self.new_form\n return dict(value=kw, \n page=u\"Nuevo Atributo\", \n action=url_action, \n atras=url_action)","def new():\n session = current_app.config['db']\n if request.method == \"POST\":\n new_name = request.form['itemname']\n try:\n item = WineABV(name=new_name)\n session.add(item)\n session.commit()\n except exc.IntegrityError:\n session.rollback()\n flash(\"Duplicate values!\", 'danger')\n item = WineABV(name=new_name)\n return render_template(template_prefix+'/new_form.html', item=item)\n\n flash(\"Successfully Added '%s'\" % (new_name,), 'success')\n return redirect(url_for('.show'))\n else:\n item = WineABV(name=\"\")\n return render_template(template_prefix+'new_form.html', item=item)","def createItem(name, category, price, user_id):\n try:\n description = wikipedia.summary(name)\n except wikipedia.exceptions.DisambiguationError as e:\n description = wikipedia.summary(name + \" \" + category.name)\n\n i = Item(name=name, description=description,\n category_id=category.id, price=price, user_id=user_id)\n session.add(i)\n session.commit()\n print 'Item \"' + name + '\" added.'\n return i","def test_create_item(self):\n item = self.item\n\n self.assertTrue(isinstance(item, Item))\n self.assertEqual(item.name, \"Test Item\")","def item_create(\n item, item_id, item_type, create=\"create\", extra_args=None, cibfile=None\n):\n cmd = [\"pcs\"]\n if isinstance(cibfile, str):\n cmd += [\"-f\", cibfile]\n\n if isinstance(item, str):\n cmd += [item]\n elif isinstance(item, (list, tuple)):\n cmd += item\n\n # constraint command follows a different order\n if item in [\"constraint\"]:\n if isinstance(item_type, str):\n cmd += [item_type]\n\n if isinstance(create, str):\n cmd += [create]\n elif isinstance(create, (list, tuple)):\n cmd += create\n\n # constraint command needs item_id in format 'id=<id' after all params\n # constraint command follows a different order\n if item not in [\"constraint\"]:\n cmd += [item_id]\n if isinstance(item_type, str):\n cmd += [item_type]\n\n if isinstance(extra_args, (list, tuple)):\n # constraint command needs item_id in format 'id=<id' after all params\n if item in [\"constraint\"]:\n extra_args = extra_args + [\"id={}\".format(item_id)]\n cmd += extra_args\n\n return __salt__[\"cmd.run_all\"](cmd, output_loglevel=\"trace\", python_shell=False)","def add_item(request):\n \n if not request.user.is_superuser:\n messages.error(request, 'Sorry, you are not permitted to do that.')\n return redirect(reverse('home'))\n\n if request.method == 'POST':\n form = ProductForm(request.POST, request.FILES)\n if form.is_valid():\n form.save()\n messages.success(request, 'New item added successfully!')\n return redirect(reverse('add_item'))\n else:\n messages.error(request, 'Failed to add item. Please check the form.')\n else:\n form = ProductForm()\n \n template = 'products/add_item.html'\n context = {\n 'form': form,\n }\n\n return render(request, template, context)","def create_items(sender, instance, **kwargs):\n if instance.item_id is None and instance.item is None:\n item = Item()\n if hasattr(instance, 'active'):\n item.active = getattr(instance, 'active')\n item.save()\n instance.item = item","def add_items_handler():\n rq = request.get_json()\n name = rq['name']\n picture = rq['picture']\n description = rq['description']\n category_id = rq['category_id']\n item = addItem(name, picture, description, category_id, g.user.id)\n return jsonify(item=item.serialize)","def newCategory():\n if request.method == 'POST':\n if request.form['name'] != \" \":\n new_Category = Category(name=request.form['name'],\n user_id=login_session['user_id'])\n session.add(new_Category)\n session.commit()\n flash('New Category %s Successfully Created'\n % new_Category.name)\n return redirect(url_for('showCatalog'))\n else:\n flash('Name fields can\\'t be left blank!')\n return render_template('newcategory.html')\n else:\n return render_template('newcategory.html')","def add_item(self):\n item = LibGen.create_item()\n if not self.item_exists(item.call_number):\n self.item_list[item.call_number] = item\n print(f\"Item({item.call_number}) bas been added.\")\n else:\n print(\"This item already exists.\")","def test_add_cart_item_unauthorized_user(self):\n cart_id = self.cart_item_manager.create_cart('111', 'test cart', False)\n with self.assertRaises(ResourceAccessError):\n self.cart_item_manager.add_cart_item(catalog=self.catalog,\n user_id='112',\n cart_id=cart_id,\n entity_id='entity_id',\n entity_type='entity_type',\n entity_version='entity_version')","def test_add_item_to_cart(client):\n raise NotImplemented('Acceptance test failed')","def post(self, request):\n\n try:\n\n industry_data = Industry.objects.get(\n naics_code=request.data['naics_code'])\n category_data = JobCategory.objects.get(\n o_net_soc_code=request.data['category'])\n data, __ = JobCatalog.objects.get_or_create(\n naics_code=industry_data, category=category_data)\n if __:\n message = \"Catalog created\"\n else:\n message = \"Catalog already exists\"\n\n return Response({\"message\": message},\n status=status.HTTP_201_CREATED)\n except Exception as e:\n return Response({\"error\": \"{}\".format(e)},\n status=status.HTTP_400_BAD_REQUEST)","def create_item_variant():\n if not request.json:\n abort(400)\n parser = reqparse.RequestParser()\n parser.add_argument('item_code', type=int, required=True, location='json', help=\"Item code missing\")\n parser.add_argument('cost_price', type=float, required=True, location='json', help=\"Cost Price missing\")\n parser.add_argument('selling_price', type=float, required=True, location='json', help=\"Selling Price missing\")\n parser.add_argument('quantity', type=int, required=True, location='json', help=\"Quantity missing\")\n parser.add_argument('username', type=str, required=True, location='json', help=\"Username missing\")\n args = parser.parse_args()\n user_code = get_user_code(args['username'])\n if user_code is None:\n return make_response(jsonify({'error': 'User does not exists'}), 400)\n new_variant = dict(\n cost_price = args['cost_price'],\n selling_price = args['selling_price'],\n quantity = args['quantity']\n )\n try:\n u = models.Items.query.filter_by(item_code=args['item_code']).first()\n if u is None:\n return make_response(jsonify({'error': 'Item does not exists'}), 400)\n v = models.Variants(**new_variant)\n u.variants = v\n db.session.add(u)\n db.session.commit()\n except sqlalchemy.exc.IntegrityError, e:\n return make_response(jsonify({'error': 'Item code already exists.'}), 400)\n return make_response(jsonify({'success': True}))","def create(self, *args, **kwargs):\n pass","def created(event):\n root = event.object\n registry = event.registry\n root.sdi_title = 'Simple Book Catalog'\n service = root['catalogs']\n service.add_catalog('books', update_indexes=True)\n books = registry.content.create('BookFolder', name='books', title='Books')\n root['books'] = books","def create(self):\n ...","def create_new_product(self):\n if len(self.lineEdit_name.text()) != 0 and len(self.lineEdit_desc.text()) != 0 and len(\n self.lineEdit_cost.text()) != 0 and len(self.lineEdit_cat.text()) != 0:\n try:\n cost = float(self.lineEdit_cost.text())\n list = self.product_list()\n try:\n add_product(list)\n self.frame_3.show()\n self.label_16.setText('NEW PRODUCT CREATE SUCCESSFULLY!')\n except:\n self.frame_3.show()\n self.label_16.setText('ERROR CREATE NEW PRODUCT!')\n\n except ((ValueError)):\n self.frame_3.show()\n self.label_16.setText('IN THE COST FIELDS: JUST NUMBERS!')\n\n '''else:\n self.frame_3.show()\n self.label_16.setText('IN THE COST FIELDS: JUST NUMBERS!')'''\n else:\n self.frame_3.show()\n self.label_16.setText('THERE CAN BE NO BLANCK FIELDS!')","def add_new_product():\n name = request.args.get(\"name\")\n email = request.args.get(\"email\")\n description = request.args.get(\"description\")\n price = request.args.get(\"price\")\n recommended = request.args.get(\"recommended\", default=\"n\")\n funcs.add_product(name, price, description, recommended, email)\n return json.dumps({'success': True}), 200, {'ContentType': 'application/json'}","def admincreate(object):\n if request.method == \"POST\":\n\n db = get_db()\n execute_string = 'INSERT INTO ' + object.title()\n\n if object == 'post':\n execute_string += '(title, content, authorId, categoryId) VALUES (\"' + request.form['title'] + '\", \"' + request.form[\"content\"] + '\", \"' + request.form[\"authorid\"] + '\", \"' + request.form[\"categoryid\"] + '\")'\n elif object == 'author':\n execute_string += '(name) VALUES (\"' + request.form['name'] + '\")'\n elif object == 'category':\n execute_string += '(name, description) VALUES (\"' + request.form['name'] + '\", \"' + request.form[\"description\"] + '\")'\n\n db.execute(execute_string)\n db.commit()\n return redirect(url_for(\"adminview\", object=object))\n\n return render_template(\"new.html\", object=object, item={})","def addItem(category_id):\r\n # authentication\r\n if 'username' not in login_session:\r\n flash('Please login to add item')\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n # validation\r\n category = session.query(Category).filter_by(id=category_id).first()\r\n if not category:\r\n flash('Attempted operation on non-existent category')\r\n return redirect(url_for('showCategories'))\r\n\r\n if request.method == 'POST':\r\n # create operation\r\n name = request.form['name']\r\n description = request.form['description']\r\n if not name:\r\n flash('Add ItemError: Name can\\'t be empty')\r\n return redirect(url_for('showItems', category_id=category_id))\r\n newItem = Item(name=name, description=description,\r\n category_id=category_id, user_id=category.user_id)\r\n session.add(newItem)\r\n session.commit()\r\n flash('Added Item \\'{}\\' Successfully!'.format(newItem.name))\r\n return redirect(url_for('showItems', category_id=category_id))\r\n else:\r\n # serve GET requests with the form\r\n return render_template(\"addItem.html\", category=category)","def create(self, request, *args, **kwargs):\n response = super(ProductViewSet, self).create(request, *args, **kwargs)\n response.data['message'] = \"Producto ha sido creado\"\n return response","def test_admin_create_product(self):\n resp = self.admin_register()\n reply = self.admin_login()\n token = reply['token']\n product = dict(\n prod_name='NY_denims',\n category='denims',\n stock=20,\n price=150\n )\n resp = self.client.post(\n '/api/v1/products',\n content_type='application/json',\n data=json.dumps(product),\n headers={'Authorization': 'Bearer {}'.format(token)}\n )\n reply = json.loads(resp.data.decode())\n \n self.assertEqual(reply['message'], 'Product successfully added to Inventory!')\n self.assertEqual(resp.status_code, 201)","def create_item(item: Item):\n coll_users = data_access.get_user_collection()\n coll_items = data_access.get_items_collection()\n\n if not item.users:\n raise HTTPException(status.HTTP_400_BAD_REQUEST,\n \"Empty user list not allowed.\")\n\n if not item.content:\n raise HTTPException(status.HTTP_400_BAD_REQUEST,\n \"No description / content given.\")\n\n for user_name in item.users:\n if coll_users.find_one({\"name\": user_name}) is None:\n raise HTTPException(status.HTTP_400_BAD_REQUEST,\n f\"User {user_name} not exists in the user list.\")\n\n item_dict = item.dict()\n item_dict[\"item_id\"] = uuid.uuid4()\n\n tm_now = datetime.datetime.now().isoformat()\n item_dict[\"status_change_date\"] = tm_now\n\n coll_items.insert_one(item_dict)","def createItem(self, item):\r\n try:\r\n self.feed_handler.createItem(item.link, item.title, item.descr,\r\n item.source, item.channelURL)\r\n self.feed_passed = self.feed_passed + 1\r\n except Exception, ex: \r\n # Remove comment for detailed information on feed item created\r\n #print ex\r\n pass","def add_item():\n\n form = AddOrEditItemForm(Category.query.order_by(Category.name).all())\n img_upload_name = None\n if form.validate_on_submit():\n img_upload_name = secure_filename(form.img_upload.data.filename)\n img_deletehash = None\n img_url = None\n\n # Upload image to Imgur if FileField is specified\n if img_upload_name != '':\n img_url, img_deletehash = upload_image(form.img_upload.data)\n if img_url is None or img_deletehash is None:\n flash(\"Failed to upload image.\")\n return redirect(url_for('.index'))\n elif form.img_url.data != '':\n img_url = form.img_url.data\n\n new_item = Item(name=form.name.data, description=form.description.data,\n category=Category.query.get(form.category.data),\n img_url=img_url, img_deletehash=img_deletehash,\n owner=current_user._get_current_object())\n\n try:\n db.session.add(new_item)\n db.session.commit()\n except:\n flash(\n (\"Failed to add item \\\"%s\\\".\"\n \" Make sure that the item name is unique.\") % new_item.name)\n else:\n flash(\"A new item \\\"%s\\\" has been added.\" % new_item.name)\n finally:\n return redirect(url_for('.index'))\n\n # Set SelectField's default value\n category_name = request.args.get('category_name')\n if category_name is not None:\n default_category = Category.query.filter_by(name=category_name).first()\n if default_category is None:\n flash(\"Wrong parameter(s).\")\n return redirect(url_for('.index'))\n form.category.data = default_category.id\n\n return render_template('add_or_edit.html',\n form=form, filename=img_upload_name)","def save_item(item, item_id):\n # User is modifying an EXISTING item in the database\n if item_id > 0:\n item.Item.name = request.form['title']\n item.Item.description = request.form['description']\n item.Item.category_id = request.form['category']\n session.add(item.Item)\n session.commit()\n flash(\"Updated \" + item.Item.name)\n return render_template('item_details.html', item=item, login_session=login_session)\n\n # User is creating a NEW item\n else:\n new_item = Item(name=request.form.get('title'), description=request.form['description'],\n category_id=request.form['category'],\n user_id=login_session['userid'])\n session.add(new_item)\n session.commit()\n flash(\"Created \" + new_item.name)\n created_item = session.query(Item, User).filter(Item.id == new_item.id).join(User).first()\n return render_template('item_details.html', item=created_item, login_session=login_session)","def add_item(self, obj): # deprecated\n logger.info('ItemProduct adding item initiated')\n try:\n if not obj['edit']:\n unit, = self.ProductUom.find([('name', '=', obj['units'])])\n template = self.ProductTemplate()\n try:\n if self.Product.find([('code', '=', obj['id']), ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]:\n return False\n if self.Product.find([('name', '=', obj['name']), ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]:\n return False\n except Exception:\n pass\n template.category = self.ProductCategory.find([('name', '=', obj['category'])])[-1]\n template.default_uom = unit\n template.purchase_uom = unit\n template.type = 'goods'\n else:\n product = self.Product.find([('code', '=', obj['id']), ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n template = product.template\n unit, = self.ProductUom.find([('name', '=', obj['units'])])\n template.default_uom = unit\n template.purchase_uom = unit\n template.category = self.ProductCategory.find([('name', '=', obj['category'])])[-1]\n\n rate = Decimal(obj['rate'])\n cost = rate / 2\n template.name = obj['name']\n template.list_price = Decimal(rate)\n template.cost_price = Decimal(cost)\n template.purchasable = True\n template.account_expense = self.accounts['expense']\n template.account_receivable = self.accounts['receivable']\n product = self.Product.find([('name', '=', template.name),\n ('description', '=', 'Stock'), ('type', '=', 'goods')])\n if product:\n product = product[-1]\n else:\n product = self.Product.find([('name', '=', template.name), ('type', '=', 'goods')])\n ids = []\n for i in product:\n ids.append(i.id)\n ids.sort()\n print \"ids\", ids\n product = self.Product(id=ids[-1])\n product.code = obj['id']\n product.description = 'Stock'\n product.save()\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False","def update_category_item(catalog_item_id):\n edited_item = session.query(CatalogItem). \\\n filter_by(id=catalog_item_id).one()\n if request.form['name']:\n edited_item.name = request.form['name']\n if request.form['description']:\n edited_item.description = request.form['description']\n if request.form['price']:\n edited_item.price = request.form['price']\n session.add(edited_item)\n session.commit()","def create(self, user, product, quantity):\n\n cart_product = CartProduct.create(user, product, quantity)\n CartProductsView.create(cart_product)","def newMenuItem(restaurant_id):\n\n if 'access_token' not in flask_session:\n return logInRedirect()\n restaurant = session.query(Restaurant).filter_by(id = restaurant_id).first()\n user_id = getUserId(flask_session['email'],flask_session['google_plus_id'])\n if not restaurant.user_id == user_id:\n flash(\"Only restaurant owners can add new items.\")\n return redirect(url_for(\"publicMenu\",restaurant_id = restaurant_id))\n\n if request.method == \"POST\":\n new_name = request.form['new_name']\n print \"\\nnewMenuItem POST triggered, name is: \", new_name\n newMenuItem = MenuItem( name=new_name,\n restaurant_id=restaurant.id )\n session.add(newMenuItem)\n session.commit()\n flash( \"new item '\" + new_name + \"' created!\")\n print \"POST worked!\"\n return redirect(url_for(\"showMenu\", restaurant_id=restaurant.id))\n\n else:\n return render_template('newMenuItem.html', restaurant = restaurant)","def add_item(self, name, description, category_id, user_id):\r\n category = self._db_manager.get_category(category_id)\r\n if category is None:\r\n flash(\"Invalid category.\")\r\n return\r\n if category[\"user_id\"] != user_id:\r\n flash(\"You can only add items to categories you created.\")\r\n return\r\n item_id, message = self._db_manager.add_item(\r\n name=name,\r\n description=description,\r\n category_id=category_id,\r\n user_id=user_id\r\n )\r\n flash(message)\r\n return item_id","def create(self):\n self.add_handlers({\"^T\": self.change_forms,\"^Q\": self.exit})\n self.add(npyscreen.TitleFixedText, name='Inventory items:', value='')\n self.inventory_mle = self.add(npyscreen.Pager,\n values=['Checking for plugins in the inventory, please wait...'])","def restaurantMenuItemNew(restaurant_id):\n try:\n restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()\n if request.method == 'POST':\n if request.form['name']:\n newItem = MenuItem(name=request.form['name'], description=request.form[\n 'description'], price=request.form['price'], course=request.form['course'], restaurant_id=restaurant_id)\n session.add(newItem)\n session.commit()\n\n flash('Menu Item Created', 'menu')\n return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id))\n else:\n return render_template('menuItemNew.html', restaurant=restaurant)\n\n except exc.NoResultFound:\n return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id))","def test_add_cart_item_nonexistent_cart(self):\n with self.assertRaises(ResourceAccessError):\n self.cart_item_manager.add_cart_item(catalog=self.catalog,\n user_id='111',\n cart_id='123',\n entity_id='entity_id',\n entity_type='entity_type',\n entity_version='entity_version')","def create_item(_id, item_name, description):\n data_ = Data.get_the_data(_id, Data.bucketlists)\n for data in data_:\n bucketlist = Bucketlist(data['title'],\n data['owner'],\n data['intro'],\n data['owner_id'],\n data['_id'])\n bucketlist.new_item(item_name=item_name,\n description=description)","def add_new_item():\n\n lst = item_list()\n return render_template('index.html', sell_flag=1, items=lst)","def create_eitem(self, new_document):\n eitem_cls = current_app_ils.eitem_record_cls\n eitem_json = self.json_data.get(\"_eitem\", None)\n if eitem_json:\n try:\n self._build_eitem_dict(eitem_json, new_document[\"pid\"])\n record_uuid = uuid.uuid4()\n with db.session.begin_nested():\n provider = EItemIdProvider.create(\n object_type=\"rec\",\n object_uuid=record_uuid,\n )\n\n eitem_json[\"pid\"] = provider.pid.pid_value\n self.created = eitem_cls.create(eitem_json, record_uuid)\n db.session.commit()\n return self.created\n except IlsValidationError as e:\n click.secho(\n \"Field: {}\".format(e.errors[0].res[\"field\"]), fg=\"red\"\n )\n click.secho(e.original_exception.message, fg=\"red\")\n db.session.rollback()\n raise e","def test_add_item_using_post(self):\n pass","def create(self):\n pass","def create(self):\n pass","def create(self):\n pass","def test_create_item(self):\n\n url = reverse('stock-item-create')\n\n response = self.client.get(url, {'part': 1}, HTTP_X_REQUESTED_WITH='XMLHttpRequest')\n self.assertEqual(response.status_code, 200)\n\n response = self.client.get(url, {'part': 999}, HTTP_X_REQUESTED_WITH='XMLHttpRequest')\n self.assertEqual(response.status_code, 200)\n\n # Copy from a valid item, valid location\n response = self.client.get(url, {'location': 1, 'copy': 1}, HTTP_X_REQUESTED_WITH='XMLHttpRequest')\n self.assertEqual(response.status_code, 200)\n\n # Copy from an invalid item, invalid location\n response = self.client.get(url, {'location': 999, 'copy': 9999}, HTTP_X_REQUESTED_WITH='XMLHttpRequest')\n self.assertEqual(response.status_code, 200)","def post(self, *args, **kw):\n id_tipo_item = UrlParser.parse_id(request.url, \"tipositems\")\n url_action = \"./\"\n\n pp = PoseePermiso('redefinir tipo item',id_tipo_item=id_tipo_item)\n \n if not pp.is_met(request.environ):\n flash(pp.message % pp.nombre_permiso, 'warning')\n redirect(url_action)\n \n if kw.has_key(\"sprox_id\"):\n del kw[\"sprox_id\"]\n\n tipo = TipoItem.por_id(id_tipo_item)\n try:\n tipo.agregar_atributo(**kw)\n except NombreDeAtributoError, err:\n flash(unicode(err), \"warning\")\n\n redirect(url_action)","def menu_item_new(restaurant_id):\n # If the user isn't logged in, send to the login page\n if helper.handle_login(login_session) is False:\n return redirect('/login')\n\n restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()\n img_id = 0\n if request.method == 'POST':\n if 'file' in request.files:\n print(\"File found\")\n img_id = helper.create_new_image_if_not_exists(file=request.files['file'],\n title=request.form['img_name'])\n new_item = MenuItem(name=request.form['name'],\n description=request.form['description'],\n price=request.form['price'],\n course=request.form['course'],\n likes=0,\n dislikes=0,\n restaurant_id=restaurant_id,\n user_id=login_session['user_id'],\n image_id=img_id)\n session.add(new_item)\n session.commit()\n flash(\"New Menu Item {} created!\".format(new_item.name))\n return redirect(url_for('restaurant_menu', restaurant_id=restaurant_id))\n else:\n user_info = helper.get_user_if_exists(login_session)\n return render_template('newmenuitem.html', restaurant=restaurant, user_info=user_info)","def newCategory():\n\n if 'username' not in login_session:\n return redirect('/login')\n if request.method == 'POST':\n if \"btn_new\" in request.form:\n newCategory = Category(name=request.form['name'],\n user_id=login_session['user_id'])\n session.add(newCategory)\n flash('New Category %s Successfully Created' % newCategory.name)\n session.commit()\n return redirect(url_for('showCategories'))\n else:\n return redirect(url_for('showCategories'))\n else:\n return render_template('newCategory.html',\n user=getUserInfo(login_session['user_id']))","def test_creating_shopping_item(create_shopping_item, create_user):\n owner = create_user\n shopping_item = create_shopping_item\n assert shopping_item.owner == owner","def new_category():\n if request.method == 'POST':\n genre = Category(name=request.form['new_category'],\n user_id=login_session['user_id'])\n session.add(genre)\n try:\n session.commit()\n except:\n session.rollback()\n flash(\"Error: Cannot have two categories with the same name!\")\n return redirect(url_for('show_categories'))\n else:\n return render_template(\"newcategory.html\")","async def command_create(self, context):\n # await self._create_new_role(context, name, target=GROUP_CATEGORY_NAME)\n print('main create')","def create(self):","def create_shop(request):\n\n shop = Shop.objects.filter(title=request.data[\"shopName\"].lower())\n if shop.exists():\n return Response({\"is_exist\": True, \"msg\": \"This shop already exist\"})\n shop = Shop.objects.create(\n title=request.data[\"shopName\"].lower(),\n category=request.data[\"shopCategory\"],\n phone_number=request.data[\"phoneNumber\"],\n user=request.user,\n )\n shop.save()\n return Response({\"is_exist\": False, \"msg\": \"Success.\", \"slug\": shop.slug})","def test_new_item(self):\n\n\t\titem_id = mock_item()[0]\n\t\tself.assertEqual(item_id, 1)","def create_product(sender, instance, **kwargs):\n if kwargs.get(\"created\"): # True just for first time when obj created\n logger.info(f\"Emails send to user with new product <{instance}>\")","def create(self):\n\n pass","def test_add_product(self):\n view = ProductCreateListView.as_view({'post': 'create'})\n uri = reverse('products:create/list-products')\n data = {\n \"name\": \"Iphone 7\",\n \"description\": \"Mobile phone\",\n \"price\": 200,\n \"is_available\": True\n }\n request = self.factory.post(uri, data, HTTP_AUTHORIZATION='Token {}'.format(self.token_admin.key))\n request.user = self.user['admin']\n response = view(request)\n self.assertEqual(response.status_code, 201,\n f'Expected Response Code 201, received {response.status_code} instead.')","def newCategory():\n if request.method == 'POST':\n new_Category = Category(name=request.form['name'],\n image=request.form['image'],\n user_id=login_session['user_id'])\n session.add(new_Category)\n session.commit()\n flash('New Category created')\n return redirect(url_for('showallCategories'))\n else:\n return render_template('newCategory.html')","def add_to_cart(db, itemid, quantity):","def perform_create(self, serializer):\n item = models.ProfileItem.objects.get(pk=self.kwargs.get(\"pk\"))\n\n return serializer.save(profile_item=item)","def addnewitem():\n\n itemcode = input(\"Enter item code: \")\n itemdescription = input(\"Enter item description: \")\n itemrentalprice = input(\"Enter item rental price: \")\n\n # Get price from the market prices module\n itemprice = get_latest_price(itemcode)\n\n isfurniture = input(\"Is this item a piece of furniture? (Y/N): \")\n if isfurniture.lower() == \"y\":\n add_furniture(itemcode, itemdescription, itemprice, itemrentalprice)\n else:\n iselectricappliance = input(\"Is this item an electric appliance?\"\n \" (Y/N): \")\n if iselectricappliance.lower() == \"y\":\n add_appliance(itemcode, itemdescription, itemprice, itemrentalprice)\n add_non_furniture_nor_appliance(itemcode, itemdescription, itemprice,\n itemrentalprice)\n print(\"New inventory item added\")","def test_add_item_adds_single_entry():\n sc.menu = sc.default_menu\n sc.current.add_item('Coffee', 1)\n assert sc.current.receipt == {'subtotal': 1.59, 'Coffee': 1}","def newMenuItemPage(restaurant_id):\n restaurant = db_methods.searchResByID(restaurant_id)\n res_id = restaurant_id\n user_id = login_session['user_id']\n if request.method == 'POST':\n item_name = request.form['item_name']\n item_price = request.form['item_price']\n item_desc = request.form['item_desc']\n item_course = request.form['item_course']\n if item_name and item_price and item_desc and item_course:\n db_methods.addNewMenuItem(user_id, item_name, item_price, \n item_desc, item_course, res_id)\n time.sleep(0.1)\n return redirect(\"/restaurants/%s/menu/\" % res_id)\n else:\n error = \"Please be sure to fill out all required fields.\"\n return render_template('newmenuitem.html', error = error)\n else:\n return render_template('newmenuitem.html', res_id = res_id)","def test_create_inventory_with_no_name(self):\n new_inventory = {'status': 'new'}\n resp = self.app.post('/inventories', data=new_inventory, content_type='application/json')\n self.assertEqual(resp.status_code, status.HTTP_400_BAD_REQUEST)","def test_cart_creation(self):\n user_id = '123'\n cart_name = 'cart name'\n cart_id = self.cart_item_manager.create_cart(user_id, cart_name, False)\n cart = self.dynamo_accessor.get_item(config.dynamo_cart_table_name, {'UserId': user_id, 'CartId': cart_id})\n self.assertEqual(cart['UserId'], user_id)\n self.assertEqual(cart['CartName'], cart_name)\n self.assertEqual(self.cart_item_manager.user_service.get_or_create(user_id)['DefaultCartId'], None)","def handle_add(self, controller):\n \n controller.customer.CreatePizza()\n controller.show_frame(PageOne)","def save_catalog(self, catalog_form, *args, **kwargs):\n # Implemented from kitosid template for -\n # osid.resource.BinAdminSession.update_bin\n if catalog_form.is_for_update():\n return self.update_catalog(catalog_form, *args, **kwargs)\n else:\n return self.create_catalog(catalog_form, *args, **kwargs)","def create_item(obj: endpoint_model):\n # should this error if exists?\n new_obj = db.save(obj)\n return new_obj","def create_product():\n form = ProductForm(request.form)\n if form.validate():\n product = Product()\n product.name = form.name.data\n product.price = form.price.data\n product.quantity = form.quantity.data\n product.description = form.description.data\n product.category = form.category.data\n product.unique_tag = form.unique_tag.data\n db.session.add(product)\n db.session.commit()\n flash(f\"Product {product.name} created!\")\n return redirect(url_for('get_products'))\n\n flash(\"Invalid data\")\n return redirect(url_for('get_products'))","def save_item(self, obj):\n logger.info('ItemProduct adding item initiated')\n try:\n with Transaction().start(DBNAME, 1) as transaction:\n product = self.Product.search([('code', '=', obj['id']), ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n template = self.ProductTemplate(id=product.template.id)\n unit, = self.ProductUom.search([('name', '=', obj['units'])])\n template.default_uom = unit\n template.purchase_uom = unit\n template.category = self.ProductCategory.search([('name', '=', obj['category'])])[-1]\n rate = Decimal(obj['rate'])\n cost = rate / 2\n template.name = obj['name']\n template.list_price = Decimal(rate)\n template.cost_price = Decimal(cost)\n template.purchasable = True\n template.account_expense = self.accounts['expense']\n template.account_receivable = self.accounts['receivable']\n template.save()\n # transaction.cursor.commit()\n product.description = 'Stock'\n product.save()\n transaction.cursor.commit()\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False","def create():\n pass","def add_appliance(itemcode, description, marketprice, rentalprice):\n\n itembrand = input(\"Enter item brand: \")\n itemvoltage = input(\"Enter item voltage: \")\n newitem = ElectricAppliances \\\n (itemcode, description, marketprice, rentalprice,\n itembrand, itemvoltage)\n\n FULLINVENTORY[itemcode] = newitem.returnasdictionary()\n print(\"New inventory item added\")","async def admin_add_item(self, ctx, *item_infos: tuple):\n items = get_file(\"items\")\n item_infos = \"\".join(item_infos)\n item_id, item_name, item_from, item_desc, item_tier = item_infos.split(\",\")\n items[item_id] = {\"name\": item_name, \"from\": item_from, \"description\": item_desc, \"tier\": item_tier}\n update_file(\"items\", items)\n\n embed = discord.Embed(color=admin_color)\n embed.set_author(name=\"🛠️ Admin\")\n embed.add_field(name=\"➕ Add item\", value=f\"{ctx.author.mention}, l'item : **{item_name}** ({item_id}) a été ajouté\")\n embed = set_footer(embed, ctx)\n await ctx.send(embed=embed)"],"string":"[\n \"def create_item(self, user: User, **kwargs) -> None:\",\n \"def addCatalogItem(sport_id):\\n\\n sport = session.query(Sport).filter_by(id=sport_id).one()\\n if request.method == 'POST':\\n newCatalogItem = Item(\\n name=request.form['itemName'],\\n description=request.form['itemDescription'],\\n sport_id=sport_id,\\n user_id=login_session['user_id'])\\n session.add(newCatalogItem)\\n session.commit()\\n return redirect(url_for('showCatalog', sport_id=sport_id))\\n else:\\n return render_template('newcatalogitem.html', sport_id=sport_id)\",\n \"def create_item():\\n name = request.form['name']\\n catagory = request.form['catagory']\\n description = request.form['description']\\n errors = form_errors(request.form)\\n if errors:\\n catagories = [c.name for c in Catagory.fetch_all()]\\n values = {\\n 'name': name, 'catagory': catagory, 'description': description\\n }\\n return render_template(\\n 'add_item.html',\\n catagories=catagories,\\n values=values,\\n errors=errors\\n )\\n Item.create(name, catagory_name=catagory, description=description)\\n return redirect(url_for(\\n 'read_item', catagory_name=catagory, item_name=name\\n ))\",\n \"def createItem(category_id):\\r\\n if 'username' not in login_session:\\r\\n return redirect(url_for('showLogin'))\\r\\n if request.method == 'POST':\\r\\n session = DBSession()\\r\\n item = Item(name=request.form['name'],\\r\\n description=request.form['description'],\\r\\n category_id=category_id,\\r\\n user_id=login_session['user_id'])\\r\\n session.add(item)\\r\\n session.commit()\\r\\n return redirect(url_for('showCategoryItems', category_id=category_id))\\r\\n else:\\r\\n return render_template('newitem.html', category_id=category_id)\",\n \"def new_item():\\n if request.method == 'POST':\\n new_item = Item(\\n category_id=int(request.form['category']),\\n name=request.form['name'],\\n description=request.form['description'],\\n created_date=datetime.datetime.now(),\\n user_id=login_session['user_id'])\\n session.add(new_item)\\n session.commit()\\n return redirect(\\n url_for(\\n 'item_details',\\n category_id=new_item.category_id,\\n item_id=new_item.id))\\n else:\\n categories = session.query(\\n Category).all()\\n return render_template(\\n 'views/add.html',\\n categories=categories)\",\n \"def newListItem(category_id):\\n\\n if 'username' not in login_session:\\n return redirect('/login')\\n\\n category = session.query(Category).filter_by(id=category_id).one()\\n\\n if category.user_id != login_session['user_id']:\\n flash('You are not the creator of %s category, and cannot modify it' %\\n category.name)\\n return redirect(url_for('showItems', category_id=category.id))\\n if request.method == 'POST':\\n if \\\"btn_new\\\" in request.form:\\n newItem = ListItem(name=request.form['name'],\\n description=request.form['description'],\\n category_id=category_id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Catalog Item: %s Successfully Created' % (newItem.name))\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return render_template('newitem.html',\\n category_id=category_id,\\n user=getUserInfo(login_session['user_id']))\",\n \"def test_vault_create_new_vault_item(self):\\n pass\",\n \"def add_item():\\n if 'username' not in login_session:\\n response = make_response(\\n json.dumps({'error': 'User is logged out. This should not happen'}), 401\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n try:\\n if request.method == 'POST':\\n item = Item()\\n # First we populate the new item.\\n item.category_id = request.form['categoryId']\\n item.picture = request.form['picture']\\n item.name = request.form['name']\\n item.price = request.form['price']\\n item.description = request.form['description']\\n item.user_id = login_session['user_id']\\n # Now let's pull its category.\\n category = session.query(Category).filter_by(id=item.category_id).one()\\n # And make sure they're properly linked.\\n item.category = category\\n session.add(item)\\n session.flush()\\n id = item.id\\n session.commit()\\n response = make_response(\\n json.dumps({'success': '', 'nonce': login_session['state'], 'id': id}), 200\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n except Exception as inst:\\n print(type(inst))\\n print(inst.args)\\n print(inst)\",\n \"def insert_item():\\n if 'userinfo' not in session.keys():\\n session['target'] = url_for('insert_item')\\n return redirect(url_for('gconnect'))\\n if request.method == 'POST':\\n creator_email = session['userinfo']['email']\\n sqlsession = SQLSESSION()\\n user = sqlsession.query(User).filter_by(email=creator_email).first()\\n item = Item(name=request.form['name'],\\n description=request.form['description'],\\n category_id=int(request.form['category']),\\n creator_id=user.id)\\n sqlsession.add(item)\\n sqlsession.commit()\\n return redirect(\\\"/\\\")\\n sqlsession = SQLSESSION()\\n categories = sqlsession.query(Category).all()\\n return render_template(\\\"new_item.html\\\",\\n categories=categories)\",\n \"def newItem(category_id):\\n category = session.query(Category).filter_by(id=category_id).one()\\n if request.method == 'POST':\\n newItem = Item(name=request.form['name'],\\n description=request.form['description'],\\n price=request.form['price'], category_id=category.id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Item %s Successfully Created' % (newItem.name))\\n return redirect(url_for('showItem', category_id=category.id))\\n else:\\n return render_template('newitem.html', category_id=category.id)\",\n \"def newItem():\\n if request.method == 'POST':\\n if not checkLogin():\\n return requests(url_for('catelog'))\\n\\n if request.form['name'].strip() == '':\\n flash('item create failed: name is empty!')\\n return redirect(url_for('newItem'))\\n\\n category = session.query(\\n Category).filter_by(\\n name=request.form['category']).one()\\n\\n ifCategory = session.query(Category).filter_by(\\n name=request.form['category']).one()\\n ifItem = session.query(Item).filter_by(\\n category_id=ifCategory.id,\\n name=request.form['name']).all()\\n if (len(ifItem) > 0):\\n flash('item create failed: item(%s) \\\\\\n is already exist in category(%s)' % (\\n ifItem[0].name,\\n ifCategory.name))\\n return redirect(url_for('catelog'))\\n\\n newItem = Item(\\n name=request.form['name'],\\n description=request.form['description'],\\n category=category,\\n auth=getLoginUser(),\\n time=getIntTime())\\n session.add(newItem)\\n session.commit()\\n\\n flash('new item created: %s' % newItem.name)\\n\\n return redirect(url_for(\\n 'itemDetail',\\n category_name=category.name,\\n item_name=newItem.name))\\n else:\\n all_category = session.query(Category).all()\\n return render_template(\\n 'new-item.html',\\n all_category=all_category,\\n isLogin=checkLogin())\",\n \"def create_item_page():\\n catagories = [c.name for c in Catagory.fetch_all()]\\n return render_template('add_item.html', catagories=catagories, values={})\",\n \"def insert_item_page(request):\\n validate(instance=request.body, schema=item_schema)\\n body = json.loads(request.body)\\n item = Item.new_item(body['cart_id'], body['food_id'], body['count'])\\n return JsonResponse(model_to_json(item))\",\n \"def new_item():\\n form = ItemForm()\\n user = current_user\\n\\n # If the form is validated, add its data to the database\\n if form.validate_on_submit():\\n\\n # Check that an item with the same name and sport does not\\n # already exist, or send a flash message and do not add the\\n # new item to the database\\n query = Item.query.filter_by(name=form.name.data,\\n sport=form.sport.data).first()\\n if query:\\n flash('This sport already has an item with that name.', 'bad')\\n\\n # If the item does not yet exist, add all details to the\\n # database, send a flash message, and redirect to 'home'\\n else:\\n name = form.name.data\\n sport = form.sport.data\\n category = form.category.data\\n description = form.description.data\\n private = form.private.data\\n item = Item(name=name, sport=sport, category=category,\\n description=description, private=private,\\n user_id=user.id)\\n db.session.add(item)\\n db.session.commit()\\n flash(f'\\\"{name}\\\" has been added!', 'good')\\n return redirect(url_for('main.home'))\\n\\n return render_template('new_item.html', form=form, title='New Item')\",\n \"def create_item():\\n #if not request.json:\\n # abort(400)\\n parser = reqparse.RequestParser()\\n parser.add_argument('item_code', type=int, required=False, help=\\\"Item code missing\\\")\\n parser.add_argument('item_name', type=str, required=True, help=\\\"Item name missing\\\")\\n parser.add_argument('size', type=str, required=True, help=\\\"Size missing\\\")\\n parser.add_argument('color', type=str, required=True, help=\\\"Color missing\\\")\\n parser.add_argument('quality', type=str, required=True, help=\\\"Quality missing\\\")\\n parser.add_argument('username', type=str, required=True, help=\\\"Username missing\\\")\\n args = parser.parse_args(strict=True)\\n user_code = get_user_code(args['username'])\\n if user_code is None:\\n return make_response(jsonify({'error': 'User does not exists'}), 400)\\n new_item = dict(\\n item_code = args['item_code'],\\n item_name = args['item_name'],\\n size_code = get_size_code( args['size']),\\n color_code = get_color_code( args['color']),\\n quality_code = get_quality_code( args['quality'])\\n )\\n try:\\n u = models.Items(**new_item)\\n db.session.add(u)\\n db.session.commit()\\n except sqlalchemy.exc.IntegrityError, e:\\n return make_response(jsonify({'error': 'item code already exists.'}), 400)\\n\\n return make_response(jsonify({'success': True}))\",\n \"def add_item():\\n\\n form = ItemForm()\\n # Query for select field\\n form.category_id.query = Category.query.filter(\\n Category.user_id == current_user.id).all()\\n\\n if form.validate_on_submit():\\n new_item = Item(\\n category_id=form.category_id.data.id,\\n name=form.name.data.capitalize(),\\n description=form.description.data,\\n user_id=current_user.id)\\n db.session.add(new_item)\\n db.session.commit()\\n flash(\\\"New item '{}' was successfully created\\\".format(\\n form.name.data.capitalize()), category='success')\\n return redirect(url_for('url.index'))\\n\\n return render_template(\\n 'forms/form.html',\\n form_title='Add Item',\\n form=form,\\n form_name='item',\\n action=url_for('url.add_item'))\",\n \"def add(auth_context):\\n print(\\\"Add\\\")\\n uid = auth_context.get('uid')\\n item_id = request.form.get('id')\\n if item_id:\\n print(\\\"item_id: \\\"+item_id)\\n carts.add_to_cart(uid,item_id)\\n return \\\"Operation Completed\\\", 200\\n return \\\"Operation Failed\\\", 400\",\n \"def add_item(request):\\n if request.user.is_superuser:\\n if request.method == \\\"POST\\\":\\n form = ProductForm(request.POST, request.FILES)\\n if form.is_valid():\\n new_item = form.save()\\n messages.success(request, 'Your product was added to the '\\n 'store successfully.')\\n return redirect(reverse('item_info', args=[new_item.id]))\\n else:\\n messages.error(request, 'There was an issue adding the '\\n 'product. Please ensure the form is valid.')\\n else:\\n form = ProductForm()\\n else:\\n messages.error(request, 'Sorry, you do not have permission to access '\\n 'this page.')\\n return redirect(reverse('home'))\\n\\n template = 'shop/add_item.html'\\n context = {\\n 'form': form,\\n }\\n\\n return render(request, template, context)\",\n \"def newItem(category_id):\\n editedCategory = session.query(Category). \\\\\\n filter_by(id=category_id).one()\\n if editedCategory.user_id != login_session['user_id']:\\n flash('You are not authorized to edit this Category.\\\\\\n Please create your own Category in order to edit.')\\n return redirect(url_for('showCategory', category_id=category_id))\\n if request.method == 'POST':\\n newItem = Item(\\n name=request.form['name'],\\n description=request.form['description'],\\n price=request.form['price'],\\n category_id=category_id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Item created')\\n return redirect(url_for('showCategory',\\n category_id=category_id))\\n else:\\n return render_template('newItem.html', category_id=category_id)\",\n \"def put_on_sale():\\n\\n item = {\\n \\\"status\\\": 'for_sale',\\n \\\"category\\\": request.form['item-type'],\\n \\\"name\\\": request.form['item-name'],\\n \\\"price\\\": request.form['item-price'],\\n \\\"description\\\": request.form['item-description'],\\n \\\"mail\\\": request.form['seller-email']\\n }\\n\\n put_item(item)\\n\\n return redirect('/')\",\n \"def catalog_create(self, args):\\n try:\\n if args.id and self.server.connect_ermrest(args.id).exists():\\n print(\\\"Catalog already exists\\\")\\n return\\n owner = args.owner if args.owner else None\\n catalog = self.server.create_ermrest_catalog(args.id, owner)\\n if args.auto_configure:\\n model = catalog.getCatalogModel()\\n model.configure_baseline_catalog(**args.configure_args)\\n if not args.quiet:\\n print(\\\"Created new catalog %s with the following default configuration:\\\\n\\\" % catalog.catalog_id)\\n pp(catalog.get('/').json())\\n except HTTPError as e:\\n if e.response.status_code == requests.codes.not_found:\\n raise ResourceException('Catalog not found', e)\\n elif e.response.status_code == requests.codes.conflict:\\n raise ResourceException(\\\"Catalog already exists\\\", e)\\n else:\\n raise e\",\n \"def createNewItem(request):\\n newItem = ItemSerializer(data=request.data)\\n if newItem.is_valid():\\n newItem.save()\\n return Response(newItem.data, status=status.HTTP_201_CREATED)\\n\\n fail = {\\n \\\"item\\\" : \\\"item is not valid\\\"\\n }\\n return JsonResponse(fail)\",\n \"def createItem(name, description, category_id, image, user_id):\\n i = Item(name=name, description=description, category_id=category_id,\\n image=image, user_id=user_id, pub_date=datetime.utcnow())\\n db_session.add(i)\\n db_session.commit()\\n return i\",\n \"def add_item():\\n # Verify user login. If not, redirect to login page.\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n else:\\n flash('Please log in.')\\n return redirect(url_for('home'))\\n if request.method == 'POST':\\n # Get form fields\\n name = request.form['name']\\n url = request.form['url']\\n photo_url = request.form['photo_url']\\n description = request.form['description']\\n category = request.form['item_category']\\n # Retrieve the database ID of the selected category\\n category_id = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n # Retrieve user's database ID for the item's database entry\\n user_db_id = (session.query(Users)\\n .filter_by(email=login_session['email'])\\n .one()).id\\n print(\\\"Current user's database primary key id is {}.\\\"\\n .format(user_db_id))\\n print('Database ID of category is {}.'.format(category_id.id))\\n # Flash messages for incomplete item info\\n if not request.form['name']:\\n flash('Please add item name')\\n return redirect(url_for('add_item'))\\n if not request.form['url']:\\n flash('Please add item URL')\\n return redirect(url_for('add_item'))\\n if not request.form['photo_url']:\\n flash('Please add item photo URL')\\n return redirect(url_for('add_item'))\\n if not request.form['description']:\\n flash('Please add a description')\\n return redirect(url_for('add_item'))\\n # Query database for item name\\n item_name_in_db = (session.query(Items.name)\\n .filter_by(name=name)\\n .all())\\n # If the item name is already in the database, don't add\\n if item_name_in_db:\\n print('Item name \\\"{}\\\" already in database.'.format(name))\\n flash('Item name \\\"{}\\\" already in database.'.format(name))\\n return redirect(url_for('add_item'))\\n # Create object with form field info to add to database\\n new_item = Items(name=name,\\n url=url,\\n photo_url=photo_url,\\n description=description,\\n category_id=category_id.id,\\n creator_db_id=user_db_id)\\n session.add(new_item)\\n session.commit()\\n print('Item \\\"{}\\\" created.'.format(new_item.name))\\n # Return to homepage\\n return redirect(url_for('home'))\\n else:\\n # Query database with SQLAlchemy to display categories on page\\n categories = session.query(Categories).all()\\n # Render webpage\\n return render_template('add_item.html',\\n categories=categories,\\n login_status=login_status)\",\n \"def _create_item(request):\\r\\n usage_key = UsageKey.from_string(request.json['parent_locator'])\\r\\n category = request.json['category']\\r\\n\\r\\n display_name = request.json.get('display_name')\\r\\n\\r\\n if not has_course_access(request.user, usage_key.course_key):\\r\\n raise PermissionDenied()\\r\\n\\r\\n parent = get_modulestore(category).get_item(usage_key)\\r\\n dest_usage_key = usage_key.replace(category=category, name=uuid4().hex)\\r\\n\\r\\n # get the metadata, display_name, and definition from the request\\r\\n metadata = {}\\r\\n data = None\\r\\n template_id = request.json.get('boilerplate')\\r\\n if template_id:\\r\\n clz = parent.runtime.load_block_type(category)\\r\\n if clz is not None:\\r\\n template = clz.get_template(template_id)\\r\\n if template is not None:\\r\\n metadata = template.get('metadata', {})\\r\\n data = template.get('data')\\r\\n\\r\\n if display_name is not None:\\r\\n metadata['display_name'] = display_name\\r\\n\\r\\n get_modulestore(category).create_and_save_xmodule(\\r\\n dest_usage_key,\\r\\n definition_data=data,\\r\\n metadata=metadata,\\r\\n system=parent.runtime,\\r\\n )\\r\\n\\r\\n # TODO replace w/ nicer accessor\\r\\n if not 'detached' in parent.runtime.load_block_type(category)._class_tags:\\r\\n parent.children.append(dest_usage_key)\\r\\n get_modulestore(parent.location).update_item(parent, request.user.id)\\r\\n\\r\\n return JsonResponse({\\\"locator\\\": unicode(dest_usage_key), \\\"courseKey\\\": unicode(dest_usage_key.course_key)})\",\n \"def create_item(self, obj):\\n logger.info('ItemProduct adding item initiated')\\n try:\\n with Transaction().start(DBNAME, 1) as transaction:\\n unit, = self.ProductUom.search([('name', '=', obj['units'])])\\n template = self.ProductTemplate()\\n try:\\n if self.Product.search([('code', '=', obj['id']), ('description', '=', 'Stock'),\\n ('type', '=', 'goods')])[-1]:\\n return False\\n except Exception:\\n pass\\n template.category = self.ProductCategory.search([('name', '=', obj['category'])])[-1]\\n template.default_uom = unit\\n template.purchase_uom = unit\\n template.type = 'goods'\\n rate = Decimal(obj['rate'])\\n cost = rate / 2\\n template.name = obj['name']\\n template.list_price = Decimal(rate)\\n template.cost_price = Decimal(cost)\\n template.purchasable = True\\n template.account_expense = self.accounts['expense']\\n template.account_receivable = self.accounts['receivable']\\n template.save()\\n # transaction.cursor.commit()\\n product = self.Product()\\n product.template = template\\n product.code = obj['id']\\n product.description = 'Stock'\\n product.save()\\n transaction.cursor.commit()\\n return True\\n except Exception:\\n if settings.level == 10:\\n logger.exception('raised exception')\\n return False\",\n \"def _create_item(self, parent_location, category, display_name, **kwargs):\\n return ItemFactory.create(\\n parent_location=parent_location,\\n category=category,\\n display_name=display_name,\\n publish_item=False,\\n user_id=self.user.id,\\n **kwargs\\n )\",\n \"def add_new_item(self, request, *a, **kw):\\n item_def = request.data\\n cpdoc = self.get_object()\\n item_def['calendar_plan'] = cpdoc.id\\n\\n item_ser = self.get_serializer(data=item_def)\\n item_ser.is_valid(raise_exception=True)\\n item_obj = item_ser.save()\\n\\n headers = self.get_success_headers(item_ser.data)\\n return response.Response(item_ser.data, headers=headers)\",\n \"def create_item_command(cog_href: str, destination: str) -> None:\\n item = stac.create_item(cog_href)\\n\\n item.save_object(dest_href=destination)\",\n \"def new(self, *args, **kw):\\n id_tipo_item = UrlParser.parse_id(request.url, \\\"tipositems\\\")\\n url_action = \\\"./\\\"\\n\\n pp = PoseePermiso('redefinir tipo item', id_tipo_item=id_tipo_item)\\n if not pp.is_met(request.environ):\\n flash(pp.message % pp.nombre_permiso, 'warning')\\n redirect(atras)\\n tmpl_context.widget = self.new_form\\n return dict(value=kw, \\n page=u\\\"Nuevo Atributo\\\", \\n action=url_action, \\n atras=url_action)\",\n \"def new():\\n session = current_app.config['db']\\n if request.method == \\\"POST\\\":\\n new_name = request.form['itemname']\\n try:\\n item = WineABV(name=new_name)\\n session.add(item)\\n session.commit()\\n except exc.IntegrityError:\\n session.rollback()\\n flash(\\\"Duplicate values!\\\", 'danger')\\n item = WineABV(name=new_name)\\n return render_template(template_prefix+'/new_form.html', item=item)\\n\\n flash(\\\"Successfully Added '%s'\\\" % (new_name,), 'success')\\n return redirect(url_for('.show'))\\n else:\\n item = WineABV(name=\\\"\\\")\\n return render_template(template_prefix+'new_form.html', item=item)\",\n \"def createItem(name, category, price, user_id):\\n try:\\n description = wikipedia.summary(name)\\n except wikipedia.exceptions.DisambiguationError as e:\\n description = wikipedia.summary(name + \\\" \\\" + category.name)\\n\\n i = Item(name=name, description=description,\\n category_id=category.id, price=price, user_id=user_id)\\n session.add(i)\\n session.commit()\\n print 'Item \\\"' + name + '\\\" added.'\\n return i\",\n \"def test_create_item(self):\\n item = self.item\\n\\n self.assertTrue(isinstance(item, Item))\\n self.assertEqual(item.name, \\\"Test Item\\\")\",\n \"def item_create(\\n item, item_id, item_type, create=\\\"create\\\", extra_args=None, cibfile=None\\n):\\n cmd = [\\\"pcs\\\"]\\n if isinstance(cibfile, str):\\n cmd += [\\\"-f\\\", cibfile]\\n\\n if isinstance(item, str):\\n cmd += [item]\\n elif isinstance(item, (list, tuple)):\\n cmd += item\\n\\n # constraint command follows a different order\\n if item in [\\\"constraint\\\"]:\\n if isinstance(item_type, str):\\n cmd += [item_type]\\n\\n if isinstance(create, str):\\n cmd += [create]\\n elif isinstance(create, (list, tuple)):\\n cmd += create\\n\\n # constraint command needs item_id in format 'id=<id' after all params\\n # constraint command follows a different order\\n if item not in [\\\"constraint\\\"]:\\n cmd += [item_id]\\n if isinstance(item_type, str):\\n cmd += [item_type]\\n\\n if isinstance(extra_args, (list, tuple)):\\n # constraint command needs item_id in format 'id=<id' after all params\\n if item in [\\\"constraint\\\"]:\\n extra_args = extra_args + [\\\"id={}\\\".format(item_id)]\\n cmd += extra_args\\n\\n return __salt__[\\\"cmd.run_all\\\"](cmd, output_loglevel=\\\"trace\\\", python_shell=False)\",\n \"def add_item(request):\\n \\n if not request.user.is_superuser:\\n messages.error(request, 'Sorry, you are not permitted to do that.')\\n return redirect(reverse('home'))\\n\\n if request.method == 'POST':\\n form = ProductForm(request.POST, request.FILES)\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'New item added successfully!')\\n return redirect(reverse('add_item'))\\n else:\\n messages.error(request, 'Failed to add item. Please check the form.')\\n else:\\n form = ProductForm()\\n \\n template = 'products/add_item.html'\\n context = {\\n 'form': form,\\n }\\n\\n return render(request, template, context)\",\n \"def create_items(sender, instance, **kwargs):\\n if instance.item_id is None and instance.item is None:\\n item = Item()\\n if hasattr(instance, 'active'):\\n item.active = getattr(instance, 'active')\\n item.save()\\n instance.item = item\",\n \"def add_items_handler():\\n rq = request.get_json()\\n name = rq['name']\\n picture = rq['picture']\\n description = rq['description']\\n category_id = rq['category_id']\\n item = addItem(name, picture, description, category_id, g.user.id)\\n return jsonify(item=item.serialize)\",\n \"def newCategory():\\n if request.method == 'POST':\\n if request.form['name'] != \\\" \\\":\\n new_Category = Category(name=request.form['name'],\\n user_id=login_session['user_id'])\\n session.add(new_Category)\\n session.commit()\\n flash('New Category %s Successfully Created'\\n % new_Category.name)\\n return redirect(url_for('showCatalog'))\\n else:\\n flash('Name fields can\\\\'t be left blank!')\\n return render_template('newcategory.html')\\n else:\\n return render_template('newcategory.html')\",\n \"def add_item(self):\\n item = LibGen.create_item()\\n if not self.item_exists(item.call_number):\\n self.item_list[item.call_number] = item\\n print(f\\\"Item({item.call_number}) bas been added.\\\")\\n else:\\n print(\\\"This item already exists.\\\")\",\n \"def test_add_cart_item_unauthorized_user(self):\\n cart_id = self.cart_item_manager.create_cart('111', 'test cart', False)\\n with self.assertRaises(ResourceAccessError):\\n self.cart_item_manager.add_cart_item(catalog=self.catalog,\\n user_id='112',\\n cart_id=cart_id,\\n entity_id='entity_id',\\n entity_type='entity_type',\\n entity_version='entity_version')\",\n \"def test_add_item_to_cart(client):\\n raise NotImplemented('Acceptance test failed')\",\n \"def post(self, request):\\n\\n try:\\n\\n industry_data = Industry.objects.get(\\n naics_code=request.data['naics_code'])\\n category_data = JobCategory.objects.get(\\n o_net_soc_code=request.data['category'])\\n data, __ = JobCatalog.objects.get_or_create(\\n naics_code=industry_data, category=category_data)\\n if __:\\n message = \\\"Catalog created\\\"\\n else:\\n message = \\\"Catalog already exists\\\"\\n\\n return Response({\\\"message\\\": message},\\n status=status.HTTP_201_CREATED)\\n except Exception as e:\\n return Response({\\\"error\\\": \\\"{}\\\".format(e)},\\n status=status.HTTP_400_BAD_REQUEST)\",\n \"def create_item_variant():\\n if not request.json:\\n abort(400)\\n parser = reqparse.RequestParser()\\n parser.add_argument('item_code', type=int, required=True, location='json', help=\\\"Item code missing\\\")\\n parser.add_argument('cost_price', type=float, required=True, location='json', help=\\\"Cost Price missing\\\")\\n parser.add_argument('selling_price', type=float, required=True, location='json', help=\\\"Selling Price missing\\\")\\n parser.add_argument('quantity', type=int, required=True, location='json', help=\\\"Quantity missing\\\")\\n parser.add_argument('username', type=str, required=True, location='json', help=\\\"Username missing\\\")\\n args = parser.parse_args()\\n user_code = get_user_code(args['username'])\\n if user_code is None:\\n return make_response(jsonify({'error': 'User does not exists'}), 400)\\n new_variant = dict(\\n cost_price = args['cost_price'],\\n selling_price = args['selling_price'],\\n quantity = args['quantity']\\n )\\n try:\\n u = models.Items.query.filter_by(item_code=args['item_code']).first()\\n if u is None:\\n return make_response(jsonify({'error': 'Item does not exists'}), 400)\\n v = models.Variants(**new_variant)\\n u.variants = v\\n db.session.add(u)\\n db.session.commit()\\n except sqlalchemy.exc.IntegrityError, e:\\n return make_response(jsonify({'error': 'Item code already exists.'}), 400)\\n return make_response(jsonify({'success': True}))\",\n \"def create(self, *args, **kwargs):\\n pass\",\n \"def created(event):\\n root = event.object\\n registry = event.registry\\n root.sdi_title = 'Simple Book Catalog'\\n service = root['catalogs']\\n service.add_catalog('books', update_indexes=True)\\n books = registry.content.create('BookFolder', name='books', title='Books')\\n root['books'] = books\",\n \"def create(self):\\n ...\",\n \"def create_new_product(self):\\n if len(self.lineEdit_name.text()) != 0 and len(self.lineEdit_desc.text()) != 0 and len(\\n self.lineEdit_cost.text()) != 0 and len(self.lineEdit_cat.text()) != 0:\\n try:\\n cost = float(self.lineEdit_cost.text())\\n list = self.product_list()\\n try:\\n add_product(list)\\n self.frame_3.show()\\n self.label_16.setText('NEW PRODUCT CREATE SUCCESSFULLY!')\\n except:\\n self.frame_3.show()\\n self.label_16.setText('ERROR CREATE NEW PRODUCT!')\\n\\n except ((ValueError)):\\n self.frame_3.show()\\n self.label_16.setText('IN THE COST FIELDS: JUST NUMBERS!')\\n\\n '''else:\\n self.frame_3.show()\\n self.label_16.setText('IN THE COST FIELDS: JUST NUMBERS!')'''\\n else:\\n self.frame_3.show()\\n self.label_16.setText('THERE CAN BE NO BLANCK FIELDS!')\",\n \"def add_new_product():\\n name = request.args.get(\\\"name\\\")\\n email = request.args.get(\\\"email\\\")\\n description = request.args.get(\\\"description\\\")\\n price = request.args.get(\\\"price\\\")\\n recommended = request.args.get(\\\"recommended\\\", default=\\\"n\\\")\\n funcs.add_product(name, price, description, recommended, email)\\n return json.dumps({'success': True}), 200, {'ContentType': 'application/json'}\",\n \"def admincreate(object):\\n if request.method == \\\"POST\\\":\\n\\n db = get_db()\\n execute_string = 'INSERT INTO ' + object.title()\\n\\n if object == 'post':\\n execute_string += '(title, content, authorId, categoryId) VALUES (\\\"' + request.form['title'] + '\\\", \\\"' + request.form[\\\"content\\\"] + '\\\", \\\"' + request.form[\\\"authorid\\\"] + '\\\", \\\"' + request.form[\\\"categoryid\\\"] + '\\\")'\\n elif object == 'author':\\n execute_string += '(name) VALUES (\\\"' + request.form['name'] + '\\\")'\\n elif object == 'category':\\n execute_string += '(name, description) VALUES (\\\"' + request.form['name'] + '\\\", \\\"' + request.form[\\\"description\\\"] + '\\\")'\\n\\n db.execute(execute_string)\\n db.commit()\\n return redirect(url_for(\\\"adminview\\\", object=object))\\n\\n return render_template(\\\"new.html\\\", object=object, item={})\",\n \"def addItem(category_id):\\r\\n # authentication\\r\\n if 'username' not in login_session:\\r\\n flash('Please login to add item')\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n # validation\\r\\n category = session.query(Category).filter_by(id=category_id).first()\\r\\n if not category:\\r\\n flash('Attempted operation on non-existent category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n if request.method == 'POST':\\r\\n # create operation\\r\\n name = request.form['name']\\r\\n description = request.form['description']\\r\\n if not name:\\r\\n flash('Add ItemError: Name can\\\\'t be empty')\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n newItem = Item(name=name, description=description,\\r\\n category_id=category_id, user_id=category.user_id)\\r\\n session.add(newItem)\\r\\n session.commit()\\r\\n flash('Added Item \\\\'{}\\\\' Successfully!'.format(newItem.name))\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n else:\\r\\n # serve GET requests with the form\\r\\n return render_template(\\\"addItem.html\\\", category=category)\",\n \"def create(self, request, *args, **kwargs):\\n response = super(ProductViewSet, self).create(request, *args, **kwargs)\\n response.data['message'] = \\\"Producto ha sido creado\\\"\\n return response\",\n \"def test_admin_create_product(self):\\n resp = self.admin_register()\\n reply = self.admin_login()\\n token = reply['token']\\n product = dict(\\n prod_name='NY_denims',\\n category='denims',\\n stock=20,\\n price=150\\n )\\n resp = self.client.post(\\n '/api/v1/products',\\n content_type='application/json',\\n data=json.dumps(product),\\n headers={'Authorization': 'Bearer {}'.format(token)}\\n )\\n reply = json.loads(resp.data.decode())\\n \\n self.assertEqual(reply['message'], 'Product successfully added to Inventory!')\\n self.assertEqual(resp.status_code, 201)\",\n \"def create_item(item: Item):\\n coll_users = data_access.get_user_collection()\\n coll_items = data_access.get_items_collection()\\n\\n if not item.users:\\n raise HTTPException(status.HTTP_400_BAD_REQUEST,\\n \\\"Empty user list not allowed.\\\")\\n\\n if not item.content:\\n raise HTTPException(status.HTTP_400_BAD_REQUEST,\\n \\\"No description / content given.\\\")\\n\\n for user_name in item.users:\\n if coll_users.find_one({\\\"name\\\": user_name}) is None:\\n raise HTTPException(status.HTTP_400_BAD_REQUEST,\\n f\\\"User {user_name} not exists in the user list.\\\")\\n\\n item_dict = item.dict()\\n item_dict[\\\"item_id\\\"] = uuid.uuid4()\\n\\n tm_now = datetime.datetime.now().isoformat()\\n item_dict[\\\"status_change_date\\\"] = tm_now\\n\\n coll_items.insert_one(item_dict)\",\n \"def createItem(self, item):\\r\\n try:\\r\\n self.feed_handler.createItem(item.link, item.title, item.descr,\\r\\n item.source, item.channelURL)\\r\\n self.feed_passed = self.feed_passed + 1\\r\\n except Exception, ex: \\r\\n # Remove comment for detailed information on feed item created\\r\\n #print ex\\r\\n pass\",\n \"def add_item():\\n\\n form = AddOrEditItemForm(Category.query.order_by(Category.name).all())\\n img_upload_name = None\\n if form.validate_on_submit():\\n img_upload_name = secure_filename(form.img_upload.data.filename)\\n img_deletehash = None\\n img_url = None\\n\\n # Upload image to Imgur if FileField is specified\\n if img_upload_name != '':\\n img_url, img_deletehash = upload_image(form.img_upload.data)\\n if img_url is None or img_deletehash is None:\\n flash(\\\"Failed to upload image.\\\")\\n return redirect(url_for('.index'))\\n elif form.img_url.data != '':\\n img_url = form.img_url.data\\n\\n new_item = Item(name=form.name.data, description=form.description.data,\\n category=Category.query.get(form.category.data),\\n img_url=img_url, img_deletehash=img_deletehash,\\n owner=current_user._get_current_object())\\n\\n try:\\n db.session.add(new_item)\\n db.session.commit()\\n except:\\n flash(\\n (\\\"Failed to add item \\\\\\\"%s\\\\\\\".\\\"\\n \\\" Make sure that the item name is unique.\\\") % new_item.name)\\n else:\\n flash(\\\"A new item \\\\\\\"%s\\\\\\\" has been added.\\\" % new_item.name)\\n finally:\\n return redirect(url_for('.index'))\\n\\n # Set SelectField's default value\\n category_name = request.args.get('category_name')\\n if category_name is not None:\\n default_category = Category.query.filter_by(name=category_name).first()\\n if default_category is None:\\n flash(\\\"Wrong parameter(s).\\\")\\n return redirect(url_for('.index'))\\n form.category.data = default_category.id\\n\\n return render_template('add_or_edit.html',\\n form=form, filename=img_upload_name)\",\n \"def save_item(item, item_id):\\n # User is modifying an EXISTING item in the database\\n if item_id > 0:\\n item.Item.name = request.form['title']\\n item.Item.description = request.form['description']\\n item.Item.category_id = request.form['category']\\n session.add(item.Item)\\n session.commit()\\n flash(\\\"Updated \\\" + item.Item.name)\\n return render_template('item_details.html', item=item, login_session=login_session)\\n\\n # User is creating a NEW item\\n else:\\n new_item = Item(name=request.form.get('title'), description=request.form['description'],\\n category_id=request.form['category'],\\n user_id=login_session['userid'])\\n session.add(new_item)\\n session.commit()\\n flash(\\\"Created \\\" + new_item.name)\\n created_item = session.query(Item, User).filter(Item.id == new_item.id).join(User).first()\\n return render_template('item_details.html', item=created_item, login_session=login_session)\",\n \"def add_item(self, obj): # deprecated\\n logger.info('ItemProduct adding item initiated')\\n try:\\n if not obj['edit']:\\n unit, = self.ProductUom.find([('name', '=', obj['units'])])\\n template = self.ProductTemplate()\\n try:\\n if self.Product.find([('code', '=', obj['id']), ('description', '=', 'Stock'),\\n ('type', '=', 'goods')])[-1]:\\n return False\\n if self.Product.find([('name', '=', obj['name']), ('description', '=', 'Stock'),\\n ('type', '=', 'goods')])[-1]:\\n return False\\n except Exception:\\n pass\\n template.category = self.ProductCategory.find([('name', '=', obj['category'])])[-1]\\n template.default_uom = unit\\n template.purchase_uom = unit\\n template.type = 'goods'\\n else:\\n product = self.Product.find([('code', '=', obj['id']), ('description', '=', 'Stock'),\\n ('type', '=', 'goods')])[-1]\\n template = product.template\\n unit, = self.ProductUom.find([('name', '=', obj['units'])])\\n template.default_uom = unit\\n template.purchase_uom = unit\\n template.category = self.ProductCategory.find([('name', '=', obj['category'])])[-1]\\n\\n rate = Decimal(obj['rate'])\\n cost = rate / 2\\n template.name = obj['name']\\n template.list_price = Decimal(rate)\\n template.cost_price = Decimal(cost)\\n template.purchasable = True\\n template.account_expense = self.accounts['expense']\\n template.account_receivable = self.accounts['receivable']\\n product = self.Product.find([('name', '=', template.name),\\n ('description', '=', 'Stock'), ('type', '=', 'goods')])\\n if product:\\n product = product[-1]\\n else:\\n product = self.Product.find([('name', '=', template.name), ('type', '=', 'goods')])\\n ids = []\\n for i in product:\\n ids.append(i.id)\\n ids.sort()\\n print \\\"ids\\\", ids\\n product = self.Product(id=ids[-1])\\n product.code = obj['id']\\n product.description = 'Stock'\\n product.save()\\n return True\\n except Exception:\\n if settings.level == 10:\\n logger.exception('raised exception')\\n return False\",\n \"def update_category_item(catalog_item_id):\\n edited_item = session.query(CatalogItem). \\\\\\n filter_by(id=catalog_item_id).one()\\n if request.form['name']:\\n edited_item.name = request.form['name']\\n if request.form['description']:\\n edited_item.description = request.form['description']\\n if request.form['price']:\\n edited_item.price = request.form['price']\\n session.add(edited_item)\\n session.commit()\",\n \"def create(self, user, product, quantity):\\n\\n cart_product = CartProduct.create(user, product, quantity)\\n CartProductsView.create(cart_product)\",\n \"def newMenuItem(restaurant_id):\\n\\n if 'access_token' not in flask_session:\\n return logInRedirect()\\n restaurant = session.query(Restaurant).filter_by(id = restaurant_id).first()\\n user_id = getUserId(flask_session['email'],flask_session['google_plus_id'])\\n if not restaurant.user_id == user_id:\\n flash(\\\"Only restaurant owners can add new items.\\\")\\n return redirect(url_for(\\\"publicMenu\\\",restaurant_id = restaurant_id))\\n\\n if request.method == \\\"POST\\\":\\n new_name = request.form['new_name']\\n print \\\"\\\\nnewMenuItem POST triggered, name is: \\\", new_name\\n newMenuItem = MenuItem( name=new_name,\\n restaurant_id=restaurant.id )\\n session.add(newMenuItem)\\n session.commit()\\n flash( \\\"new item '\\\" + new_name + \\\"' created!\\\")\\n print \\\"POST worked!\\\"\\n return redirect(url_for(\\\"showMenu\\\", restaurant_id=restaurant.id))\\n\\n else:\\n return render_template('newMenuItem.html', restaurant = restaurant)\",\n \"def add_item(self, name, description, category_id, user_id):\\r\\n category = self._db_manager.get_category(category_id)\\r\\n if category is None:\\r\\n flash(\\\"Invalid category.\\\")\\r\\n return\\r\\n if category[\\\"user_id\\\"] != user_id:\\r\\n flash(\\\"You can only add items to categories you created.\\\")\\r\\n return\\r\\n item_id, message = self._db_manager.add_item(\\r\\n name=name,\\r\\n description=description,\\r\\n category_id=category_id,\\r\\n user_id=user_id\\r\\n )\\r\\n flash(message)\\r\\n return item_id\",\n \"def create(self):\\n self.add_handlers({\\\"^T\\\": self.change_forms,\\\"^Q\\\": self.exit})\\n self.add(npyscreen.TitleFixedText, name='Inventory items:', value='')\\n self.inventory_mle = self.add(npyscreen.Pager,\\n values=['Checking for plugins in the inventory, please wait...'])\",\n \"def restaurantMenuItemNew(restaurant_id):\\n try:\\n restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()\\n if request.method == 'POST':\\n if request.form['name']:\\n newItem = MenuItem(name=request.form['name'], description=request.form[\\n 'description'], price=request.form['price'], course=request.form['course'], restaurant_id=restaurant_id)\\n session.add(newItem)\\n session.commit()\\n\\n flash('Menu Item Created', 'menu')\\n return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id))\\n else:\\n return render_template('menuItemNew.html', restaurant=restaurant)\\n\\n except exc.NoResultFound:\\n return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id))\",\n \"def test_add_cart_item_nonexistent_cart(self):\\n with self.assertRaises(ResourceAccessError):\\n self.cart_item_manager.add_cart_item(catalog=self.catalog,\\n user_id='111',\\n cart_id='123',\\n entity_id='entity_id',\\n entity_type='entity_type',\\n entity_version='entity_version')\",\n \"def create_item(_id, item_name, description):\\n data_ = Data.get_the_data(_id, Data.bucketlists)\\n for data in data_:\\n bucketlist = Bucketlist(data['title'],\\n data['owner'],\\n data['intro'],\\n data['owner_id'],\\n data['_id'])\\n bucketlist.new_item(item_name=item_name,\\n description=description)\",\n \"def add_new_item():\\n\\n lst = item_list()\\n return render_template('index.html', sell_flag=1, items=lst)\",\n \"def create_eitem(self, new_document):\\n eitem_cls = current_app_ils.eitem_record_cls\\n eitem_json = self.json_data.get(\\\"_eitem\\\", None)\\n if eitem_json:\\n try:\\n self._build_eitem_dict(eitem_json, new_document[\\\"pid\\\"])\\n record_uuid = uuid.uuid4()\\n with db.session.begin_nested():\\n provider = EItemIdProvider.create(\\n object_type=\\\"rec\\\",\\n object_uuid=record_uuid,\\n )\\n\\n eitem_json[\\\"pid\\\"] = provider.pid.pid_value\\n self.created = eitem_cls.create(eitem_json, record_uuid)\\n db.session.commit()\\n return self.created\\n except IlsValidationError as e:\\n click.secho(\\n \\\"Field: {}\\\".format(e.errors[0].res[\\\"field\\\"]), fg=\\\"red\\\"\\n )\\n click.secho(e.original_exception.message, fg=\\\"red\\\")\\n db.session.rollback()\\n raise e\",\n \"def test_add_item_using_post(self):\\n pass\",\n \"def create(self):\\n pass\",\n \"def create(self):\\n pass\",\n \"def create(self):\\n pass\",\n \"def test_create_item(self):\\n\\n url = reverse('stock-item-create')\\n\\n response = self.client.get(url, {'part': 1}, HTTP_X_REQUESTED_WITH='XMLHttpRequest')\\n self.assertEqual(response.status_code, 200)\\n\\n response = self.client.get(url, {'part': 999}, HTTP_X_REQUESTED_WITH='XMLHttpRequest')\\n self.assertEqual(response.status_code, 200)\\n\\n # Copy from a valid item, valid location\\n response = self.client.get(url, {'location': 1, 'copy': 1}, HTTP_X_REQUESTED_WITH='XMLHttpRequest')\\n self.assertEqual(response.status_code, 200)\\n\\n # Copy from an invalid item, invalid location\\n response = self.client.get(url, {'location': 999, 'copy': 9999}, HTTP_X_REQUESTED_WITH='XMLHttpRequest')\\n self.assertEqual(response.status_code, 200)\",\n \"def post(self, *args, **kw):\\n id_tipo_item = UrlParser.parse_id(request.url, \\\"tipositems\\\")\\n url_action = \\\"./\\\"\\n\\n pp = PoseePermiso('redefinir tipo item',id_tipo_item=id_tipo_item)\\n \\n if not pp.is_met(request.environ):\\n flash(pp.message % pp.nombre_permiso, 'warning')\\n redirect(url_action)\\n \\n if kw.has_key(\\\"sprox_id\\\"):\\n del kw[\\\"sprox_id\\\"]\\n\\n tipo = TipoItem.por_id(id_tipo_item)\\n try:\\n tipo.agregar_atributo(**kw)\\n except NombreDeAtributoError, err:\\n flash(unicode(err), \\\"warning\\\")\\n\\n redirect(url_action)\",\n \"def menu_item_new(restaurant_id):\\n # If the user isn't logged in, send to the login page\\n if helper.handle_login(login_session) is False:\\n return redirect('/login')\\n\\n restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()\\n img_id = 0\\n if request.method == 'POST':\\n if 'file' in request.files:\\n print(\\\"File found\\\")\\n img_id = helper.create_new_image_if_not_exists(file=request.files['file'],\\n title=request.form['img_name'])\\n new_item = MenuItem(name=request.form['name'],\\n description=request.form['description'],\\n price=request.form['price'],\\n course=request.form['course'],\\n likes=0,\\n dislikes=0,\\n restaurant_id=restaurant_id,\\n user_id=login_session['user_id'],\\n image_id=img_id)\\n session.add(new_item)\\n session.commit()\\n flash(\\\"New Menu Item {} created!\\\".format(new_item.name))\\n return redirect(url_for('restaurant_menu', restaurant_id=restaurant_id))\\n else:\\n user_info = helper.get_user_if_exists(login_session)\\n return render_template('newmenuitem.html', restaurant=restaurant, user_info=user_info)\",\n \"def newCategory():\\n\\n if 'username' not in login_session:\\n return redirect('/login')\\n if request.method == 'POST':\\n if \\\"btn_new\\\" in request.form:\\n newCategory = Category(name=request.form['name'],\\n user_id=login_session['user_id'])\\n session.add(newCategory)\\n flash('New Category %s Successfully Created' % newCategory.name)\\n session.commit()\\n return redirect(url_for('showCategories'))\\n else:\\n return redirect(url_for('showCategories'))\\n else:\\n return render_template('newCategory.html',\\n user=getUserInfo(login_session['user_id']))\",\n \"def test_creating_shopping_item(create_shopping_item, create_user):\\n owner = create_user\\n shopping_item = create_shopping_item\\n assert shopping_item.owner == owner\",\n \"def new_category():\\n if request.method == 'POST':\\n genre = Category(name=request.form['new_category'],\\n user_id=login_session['user_id'])\\n session.add(genre)\\n try:\\n session.commit()\\n except:\\n session.rollback()\\n flash(\\\"Error: Cannot have two categories with the same name!\\\")\\n return redirect(url_for('show_categories'))\\n else:\\n return render_template(\\\"newcategory.html\\\")\",\n \"async def command_create(self, context):\\n # await self._create_new_role(context, name, target=GROUP_CATEGORY_NAME)\\n print('main create')\",\n \"def create(self):\",\n \"def create_shop(request):\\n\\n shop = Shop.objects.filter(title=request.data[\\\"shopName\\\"].lower())\\n if shop.exists():\\n return Response({\\\"is_exist\\\": True, \\\"msg\\\": \\\"This shop already exist\\\"})\\n shop = Shop.objects.create(\\n title=request.data[\\\"shopName\\\"].lower(),\\n category=request.data[\\\"shopCategory\\\"],\\n phone_number=request.data[\\\"phoneNumber\\\"],\\n user=request.user,\\n )\\n shop.save()\\n return Response({\\\"is_exist\\\": False, \\\"msg\\\": \\\"Success.\\\", \\\"slug\\\": shop.slug})\",\n \"def test_new_item(self):\\n\\n\\t\\titem_id = mock_item()[0]\\n\\t\\tself.assertEqual(item_id, 1)\",\n \"def create_product(sender, instance, **kwargs):\\n if kwargs.get(\\\"created\\\"): # True just for first time when obj created\\n logger.info(f\\\"Emails send to user with new product <{instance}>\\\")\",\n \"def create(self):\\n\\n pass\",\n \"def test_add_product(self):\\n view = ProductCreateListView.as_view({'post': 'create'})\\n uri = reverse('products:create/list-products')\\n data = {\\n \\\"name\\\": \\\"Iphone 7\\\",\\n \\\"description\\\": \\\"Mobile phone\\\",\\n \\\"price\\\": 200,\\n \\\"is_available\\\": True\\n }\\n request = self.factory.post(uri, data, HTTP_AUTHORIZATION='Token {}'.format(self.token_admin.key))\\n request.user = self.user['admin']\\n response = view(request)\\n self.assertEqual(response.status_code, 201,\\n f'Expected Response Code 201, received {response.status_code} instead.')\",\n \"def newCategory():\\n if request.method == 'POST':\\n new_Category = Category(name=request.form['name'],\\n image=request.form['image'],\\n user_id=login_session['user_id'])\\n session.add(new_Category)\\n session.commit()\\n flash('New Category created')\\n return redirect(url_for('showallCategories'))\\n else:\\n return render_template('newCategory.html')\",\n \"def add_to_cart(db, itemid, quantity):\",\n \"def perform_create(self, serializer):\\n item = models.ProfileItem.objects.get(pk=self.kwargs.get(\\\"pk\\\"))\\n\\n return serializer.save(profile_item=item)\",\n \"def addnewitem():\\n\\n itemcode = input(\\\"Enter item code: \\\")\\n itemdescription = input(\\\"Enter item description: \\\")\\n itemrentalprice = input(\\\"Enter item rental price: \\\")\\n\\n # Get price from the market prices module\\n itemprice = get_latest_price(itemcode)\\n\\n isfurniture = input(\\\"Is this item a piece of furniture? (Y/N): \\\")\\n if isfurniture.lower() == \\\"y\\\":\\n add_furniture(itemcode, itemdescription, itemprice, itemrentalprice)\\n else:\\n iselectricappliance = input(\\\"Is this item an electric appliance?\\\"\\n \\\" (Y/N): \\\")\\n if iselectricappliance.lower() == \\\"y\\\":\\n add_appliance(itemcode, itemdescription, itemprice, itemrentalprice)\\n add_non_furniture_nor_appliance(itemcode, itemdescription, itemprice,\\n itemrentalprice)\\n print(\\\"New inventory item added\\\")\",\n \"def test_add_item_adds_single_entry():\\n sc.menu = sc.default_menu\\n sc.current.add_item('Coffee', 1)\\n assert sc.current.receipt == {'subtotal': 1.59, 'Coffee': 1}\",\n \"def newMenuItemPage(restaurant_id):\\n restaurant = db_methods.searchResByID(restaurant_id)\\n res_id = restaurant_id\\n user_id = login_session['user_id']\\n if request.method == 'POST':\\n item_name = request.form['item_name']\\n item_price = request.form['item_price']\\n item_desc = request.form['item_desc']\\n item_course = request.form['item_course']\\n if item_name and item_price and item_desc and item_course:\\n db_methods.addNewMenuItem(user_id, item_name, item_price, \\n item_desc, item_course, res_id)\\n time.sleep(0.1)\\n return redirect(\\\"/restaurants/%s/menu/\\\" % res_id)\\n else:\\n error = \\\"Please be sure to fill out all required fields.\\\"\\n return render_template('newmenuitem.html', error = error)\\n else:\\n return render_template('newmenuitem.html', res_id = res_id)\",\n \"def test_create_inventory_with_no_name(self):\\n new_inventory = {'status': 'new'}\\n resp = self.app.post('/inventories', data=new_inventory, content_type='application/json')\\n self.assertEqual(resp.status_code, status.HTTP_400_BAD_REQUEST)\",\n \"def test_cart_creation(self):\\n user_id = '123'\\n cart_name = 'cart name'\\n cart_id = self.cart_item_manager.create_cart(user_id, cart_name, False)\\n cart = self.dynamo_accessor.get_item(config.dynamo_cart_table_name, {'UserId': user_id, 'CartId': cart_id})\\n self.assertEqual(cart['UserId'], user_id)\\n self.assertEqual(cart['CartName'], cart_name)\\n self.assertEqual(self.cart_item_manager.user_service.get_or_create(user_id)['DefaultCartId'], None)\",\n \"def handle_add(self, controller):\\n \\n controller.customer.CreatePizza()\\n controller.show_frame(PageOne)\",\n \"def save_catalog(self, catalog_form, *args, **kwargs):\\n # Implemented from kitosid template for -\\n # osid.resource.BinAdminSession.update_bin\\n if catalog_form.is_for_update():\\n return self.update_catalog(catalog_form, *args, **kwargs)\\n else:\\n return self.create_catalog(catalog_form, *args, **kwargs)\",\n \"def create_item(obj: endpoint_model):\\n # should this error if exists?\\n new_obj = db.save(obj)\\n return new_obj\",\n \"def create_product():\\n form = ProductForm(request.form)\\n if form.validate():\\n product = Product()\\n product.name = form.name.data\\n product.price = form.price.data\\n product.quantity = form.quantity.data\\n product.description = form.description.data\\n product.category = form.category.data\\n product.unique_tag = form.unique_tag.data\\n db.session.add(product)\\n db.session.commit()\\n flash(f\\\"Product {product.name} created!\\\")\\n return redirect(url_for('get_products'))\\n\\n flash(\\\"Invalid data\\\")\\n return redirect(url_for('get_products'))\",\n \"def save_item(self, obj):\\n logger.info('ItemProduct adding item initiated')\\n try:\\n with Transaction().start(DBNAME, 1) as transaction:\\n product = self.Product.search([('code', '=', obj['id']), ('description', '=', 'Stock'),\\n ('type', '=', 'goods')])[-1]\\n template = self.ProductTemplate(id=product.template.id)\\n unit, = self.ProductUom.search([('name', '=', obj['units'])])\\n template.default_uom = unit\\n template.purchase_uom = unit\\n template.category = self.ProductCategory.search([('name', '=', obj['category'])])[-1]\\n rate = Decimal(obj['rate'])\\n cost = rate / 2\\n template.name = obj['name']\\n template.list_price = Decimal(rate)\\n template.cost_price = Decimal(cost)\\n template.purchasable = True\\n template.account_expense = self.accounts['expense']\\n template.account_receivable = self.accounts['receivable']\\n template.save()\\n # transaction.cursor.commit()\\n product.description = 'Stock'\\n product.save()\\n transaction.cursor.commit()\\n return True\\n except Exception:\\n if settings.level == 10:\\n logger.exception('raised exception')\\n return False\",\n \"def create():\\n pass\",\n \"def add_appliance(itemcode, description, marketprice, rentalprice):\\n\\n itembrand = input(\\\"Enter item brand: \\\")\\n itemvoltage = input(\\\"Enter item voltage: \\\")\\n newitem = ElectricAppliances \\\\\\n (itemcode, description, marketprice, rentalprice,\\n itembrand, itemvoltage)\\n\\n FULLINVENTORY[itemcode] = newitem.returnasdictionary()\\n print(\\\"New inventory item added\\\")\",\n \"async def admin_add_item(self, ctx, *item_infos: tuple):\\n items = get_file(\\\"items\\\")\\n item_infos = \\\"\\\".join(item_infos)\\n item_id, item_name, item_from, item_desc, item_tier = item_infos.split(\\\",\\\")\\n items[item_id] = {\\\"name\\\": item_name, \\\"from\\\": item_from, \\\"description\\\": item_desc, \\\"tier\\\": item_tier}\\n update_file(\\\"items\\\", items)\\n\\n embed = discord.Embed(color=admin_color)\\n embed.set_author(name=\\\"🛠️ Admin\\\")\\n embed.add_field(name=\\\"➕ Add item\\\", value=f\\\"{ctx.author.mention}, l'item : **{item_name}** ({item_id}) a été ajouté\\\")\\n embed = set_footer(embed, ctx)\\n await ctx.send(embed=embed)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73387873","0.69759136","0.69521016","0.68233764","0.6724789","0.66220343","0.65843236","0.6572441","0.6484448","0.6453141","0.6386233","0.6372381","0.6363761","0.6352616","0.6330959","0.6315789","0.63058573","0.6267776","0.6242766","0.6202442","0.61834675","0.61821467","0.6173522","0.6143714","0.6128689","0.6123711","0.6095438","0.60692865","0.6058558","0.6057965","0.6019657","0.59577346","0.59517854","0.59487575","0.59263307","0.591227","0.58991635","0.58940166","0.58899295","0.58682555","0.5860905","0.5853187","0.58461237","0.58456475","0.58360493","0.58114755","0.5810774","0.5807908","0.57944256","0.57942694","0.5788552","0.57735413","0.5771525","0.5770891","0.57701856","0.5764754","0.57640064","0.57569486","0.5742262","0.57373613","0.57367814","0.57083946","0.5700288","0.5698305","0.5695072","0.5692288","0.5690922","0.5687142","0.5683617","0.5683617","0.5683617","0.5678567","0.5678498","0.56729436","0.5657043","0.5640186","0.5639276","0.5638447","0.56372094","0.5635847","0.56284016","0.5628302","0.56185454","0.5603649","0.5602598","0.5598603","0.5597414","0.55968577","0.55887383","0.5587081","0.55853957","0.5583815","0.5583635","0.55773264","0.55751634","0.5573052","0.5568006","0.55649894","0.5558782","0.55582225"],"string":"[\n \"0.73387873\",\n \"0.69759136\",\n \"0.69521016\",\n \"0.68233764\",\n \"0.6724789\",\n \"0.66220343\",\n \"0.65843236\",\n \"0.6572441\",\n \"0.6484448\",\n \"0.6453141\",\n \"0.6386233\",\n \"0.6372381\",\n \"0.6363761\",\n \"0.6352616\",\n \"0.6330959\",\n \"0.6315789\",\n \"0.63058573\",\n \"0.6267776\",\n \"0.6242766\",\n \"0.6202442\",\n \"0.61834675\",\n \"0.61821467\",\n \"0.6173522\",\n \"0.6143714\",\n \"0.6128689\",\n \"0.6123711\",\n \"0.6095438\",\n \"0.60692865\",\n \"0.6058558\",\n \"0.6057965\",\n \"0.6019657\",\n \"0.59577346\",\n \"0.59517854\",\n \"0.59487575\",\n \"0.59263307\",\n \"0.591227\",\n \"0.58991635\",\n \"0.58940166\",\n \"0.58899295\",\n \"0.58682555\",\n \"0.5860905\",\n \"0.5853187\",\n \"0.58461237\",\n \"0.58456475\",\n \"0.58360493\",\n \"0.58114755\",\n \"0.5810774\",\n \"0.5807908\",\n \"0.57944256\",\n \"0.57942694\",\n \"0.5788552\",\n \"0.57735413\",\n \"0.5771525\",\n \"0.5770891\",\n \"0.57701856\",\n \"0.5764754\",\n \"0.57640064\",\n \"0.57569486\",\n \"0.5742262\",\n \"0.57373613\",\n \"0.57367814\",\n \"0.57083946\",\n \"0.5700288\",\n \"0.5698305\",\n \"0.5695072\",\n \"0.5692288\",\n \"0.5690922\",\n \"0.5687142\",\n \"0.5683617\",\n \"0.5683617\",\n \"0.5683617\",\n \"0.5678567\",\n \"0.5678498\",\n \"0.56729436\",\n \"0.5657043\",\n \"0.5640186\",\n \"0.5639276\",\n \"0.5638447\",\n \"0.56372094\",\n \"0.5635847\",\n \"0.56284016\",\n \"0.5628302\",\n \"0.56185454\",\n \"0.5603649\",\n \"0.5602598\",\n \"0.5598603\",\n \"0.5597414\",\n \"0.55968577\",\n \"0.55887383\",\n \"0.5587081\",\n \"0.55853957\",\n \"0.5583815\",\n \"0.5583635\",\n \"0.55773264\",\n \"0.55751634\",\n \"0.5573052\",\n \"0.5568006\",\n \"0.55649894\",\n \"0.5558782\",\n \"0.55582225\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76763475"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14889,"cells":{"query":{"kind":"string","value":"Allows user to edit an existing category item"},"document":{"kind":"string","value":"def editItem(category_item_id):\n editedItem = db.findItem(id=category_item_id)\n if editedItem.user_id != login_session['user_id']:\n return not_authorized()\n if request.method == 'POST':\n db.updateItem(editedItem, request.form)\n return redirect(url_for('showCatalog'))\n return render_template(\n 'edit_item.html', categories=db.getAllCategories(), item=editedItem)"},"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 editItem(category_id, item_id):\n editedItem = session.query(Item).filter_by(id=item_id).one()\n category = session.query(Category).filter_by(id=category_id).one()\n\n if editedItem.user_id != login_session['user_id']:\n flash(\"You are authorised to edit items created by you!\")\n return redirect(url_for(\"showCatalog\"))\n\n if request.method == 'POST':\n if request.form['name']:\n editedItem.name = request.form['name']\n if request.form['description']:\n editedItem.description = request.form['description']\n if request.form['price']:\n editedItem.price = request.form['price']\n session.add(editedItem)\n session.commit()\n flash('%s Item Successfully Edited' % (editedItem.name))\n return redirect(url_for('showItem',\n category_id=editedItem.category_id))\n else:\n return render_template('edititem.html', category=category,\n item=editedItem)","def editItem(category_id, item_id):\n editedItem = session.query(Item).filter_by(id=item_id).one()\n if editedItem.user_id != login_session['user_id']:\n flash('You are not authorized to edit this Item.\\\n Please create own Item in order to edit.')\n return redirect(url_for('showallCategories'))\n if request.method == 'POST':\n if request.form['name']:\n editedItem.name = request.form['name']\n if request.form['description']:\n editedItem.description = request.form['description']\n if request.form['price']:\n editedItem.price = request.form['price']\n session.add(editedItem)\n session.commit()\n flash('Item Edit successfull')\n return redirect(url_for('showCategory', category_id=category_id))\n else:\n return render_template(\n 'editItem.html', category_id=category_id,\n item_id=item_id, item=editedItem)","def editListItem(category_id, item_id):\n\n if 'username' not in login_session:\n return redirect('/login')\n\n editedItem = session.query(ListItem).filter_by(id=item_id).one()\n category = session.query(Category).filter_by(id=category_id).one()\n\n if category.user_id != login_session['user_id']:\n flash('You are not the creator of %s category, and cannot modify it' %\n category.name)\n return redirect(url_for('showItems', category_id=category.id))\n\n if request.method == 'POST':\n if \"btn_edit\" in request.form:\n if request.form['name']:\n editedItem.name = request.form['name']\n if request.form['description']:\n editedItem.description = request.form['description']\n session.add(editedItem)\n session.commit()\n flash('Catalog Item Successfully Edited')\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return render_template('edititem.html',\n item=editedItem,\n user=getUserInfo(login_session['user_id']))","def edit_item(category, item):\n # Verify user login. If not, redirect to login page.\n login_status = None\n if 'email' in login_session:\n login_status = True\n else:\n flash('Please log in.')\n return redirect(url_for('home'))\n # Query database with SQLAlchemy to display categories on page\n categories = session.query(Categories).all()\n if request.method == 'POST':\n # Query database with SQLAlchemy and store queries as objects\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n item = (session.query(Items)\n .filter_by(name=item.replace('-', ' '))\n .one())\n # Get form fields submitted by user, or retain item info\n name = request.form['name'] if request.form['name'] else item.name\n url = request.form['url'] if request.form['url'] else item.url\n if request.form['photo_url']:\n photo_url = request.form['photo_url']\n else:\n photo_url = item.photo_url\n if request.form['description']:\n description = request.form['description']\n else:\n description = item.description\n category = request.form['item_category']\n # Retrieve the database ID of the item's category\n category_id = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n # Get user's database ID\n user_db_id = (session.query(Users)\n .filter_by(email=login_session['email'])\n .one()).id\n # Get database ID of creator\n creator_db_id = item.creator_db_id\n print(\"Current user's database primary key id is {}.\"\n .format(user_db_id))\n print(\"Item creator's database primary key id is {}.\"\n .format(creator_db_id))\n print('Item to edit is \"{}\".'.format(item.name))\n # Only allow creator to edit. If not, redirect to login.\n if user_db_id != creator_db_id:\n flash('Only the creator can edit. Please log in as creator.')\n return redirect(url_for('home'))\n # Store edits in an object\n edited_item = Items(name=name,\n url=url,\n photo_url=photo_url,\n description=description,\n category_id=category_id.id,\n creator_db_id=user_db_id)\n # Overwrite item object with new info from edited_item object\n item.name = edited_item.name\n item.url = edited_item.url\n item.photo_url = edited_item.photo_url\n item.description = edited_item.description\n item.category_id = edited_item.category_id\n session.add(item)\n session.commit()\n print('Item \"{}\" edited.'.format(edited_item.name))\n # Return to homepage\n return redirect(url_for('home'))\n else:\n # Query database with SQLAlchemy to display categories on page\n categories = session.query(Categories).all()\n # Render webpage\n return render_template('edit_item.html',\n categories=categories,\n item=item,\n login_status=login_status)","def editItem(category_id, item_id):\r\n # authentication\r\n if 'username' not in login_session:\r\n flash('Please login to edit item')\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n # validation\r\n category = session.query(Category).filter_by(id=category_id).first()\r\n if not category:\r\n flash('Attempted operation on non-existent category')\r\n return redirect(url_for('showCategories'))\r\n\r\n editedItem = session.query(Item).filter_by(id=item_id,\r\n category_id=category_id).first()\r\n if not editedItem:\r\n flash('Attempt to edit non-existent item')\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n # authorization\r\n if login_session['user_id'] != editedItem.user_id:\r\n flash('Sorry, you are not authorized to edit the item \\'{}\\''\r\n .format(editedItem.name))\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n if request.method == 'POST':\r\n # update operation\r\n if request.form['name']:\r\n editedItem.name = request.form['name']\r\n\r\n if request.form['description']:\r\n editedItem.description = request.form['description']\r\n else:\r\n editedItem.description = ''\r\n session.add(editedItem)\r\n session.commit()\r\n flash('Edited Item \\'{}\\' Successfully'.format(editedItem.name))\r\n return redirect(url_for('showItems', category_id=category_id))\r\n else:\r\n # serve GET requests with the form\r\n return render_template(\"editItem.html\",\r\n category=category, item=editedItem)","def edit_item(self, item_id, name, description, category_id, user_id):\r\n item = self._db_manager.get_item(item_id)\r\n if item is None:\r\n flash(\"Invalid item.\")\r\n return\r\n if item[\"user_id\"] != user_id:\r\n flash(\"Only the original creator can edit an item.\")\r\n return\r\n category = self._db_manager.get_category(category_id)\r\n if category is None:\r\n flash(\"Invalid category.\")\r\n return\r\n if category[\"user_id\"] != user_id:\r\n flash(\"You can only add items to categories you created.\")\r\n return\r\n flash(self._db_manager.edit_item(\r\n item_id=item_id,\r\n name=name,\r\n description=description,\r\n category_id=category_id\r\n ))","def editCategory(category_id):\n editedCategory = session.query(Category). \\\n filter_by(id=category_id).one()\n if editedCategory.user_id != login_session['user_id']:\n flash('You are not authorized to edit this Category.\\\n Please create your own Category in order to edit.')\n return redirect(url_for('showallCategories'))\n if request.method == 'POST':\n if request.form['name']:\n editedCategory.name = request.form['name']\n if request.form['image']:\n editedCategory.image = request.form['image']\n session.add(editedCategory)\n session.commit()\n flash('Category Edit successfull')\n return redirect(url_for('showallCategories'))\n else:\n return render_template(\n 'editCategory.html', category_id=category_id,\n category=editedCategory)","def edit_category(category):\n # Verify user login. If not, redirect to login page.\n login_status = None\n if 'email' in login_session:\n login_status = True\n else:\n flash('Please log in.')\n return redirect(url_for('home'))\n if request.method == 'POST':\n # Query database with SQLAlchemy and store query as an object\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n # Get form fields\n edit_category_name = request.form['edit_category_name']\n # Get user's database ID\n user_db_id = (session.query(Users)\n .filter_by(email=login_session['email'])\n .one()).id\n # Get database ID of category creator\n creator_db_id = category.creator_db_id\n print(\"Current user's database primary key id is {}.\"\n .format(user_db_id))\n print(\"Category creator's database primary key id is {}.\"\n .format(creator_db_id))\n print('Category to edit is \"{}\".'.format(category.name))\n # Only allow creator to edit. If not, redirect to login.\n if user_db_id != creator_db_id:\n flash('Only the creator can edit. Please log in as creator.')\n return redirect(url_for('home'))\n # Flash messages for incomplete item info\n if not request.form['edit_category_name']:\n flash('Please identify category.')\n return redirect(url_for('edit_category'))\n # Overwrite object with new info for database\n category.name = edit_category_name\n print('Category name for database is \"{}\".'.format(category.name))\n session.add(category)\n session.commit()\n # Return to homepage\n return redirect(url_for('home'))\n else:\n # Render webpage\n return render_template('edit_category.html',\n category_name=category,\n login_status=login_status)","def edit_item_details(item_id):\n category_id = None\n if 'category_id' in request.args:\n category_id = int(request.args['category_id'])\n if 'userid' not in login_session:\n flash('Unfortunately you need to be logged in to make changes', 'error')\n return redirect(url_for('show_homepage'))\n\n item = None\n if item_id != 0:\n item = is_user_the_creator(item_id)\n if request.method == 'GET':\n categories = session.query(Category).order_by(asc(Category.name)).all()\n return display_item(categories, item, item_id, category_id)\n else:\n return save_item(item, item_id)","def editCategory(category_id):\n\n if 'username' not in login_session:\n return redirect('/login')\n\n editedCategory = session.query(Category).filter_by(id=category_id).one()\n if editedCategory.user_id != login_session['user_id']:\n flash('You are not the creator of %s category, and cannot modify it' %\n editedCategory.name)\n return redirect(url_for('showCategories'))\n else:\n if request.method == 'POST':\n if \"btn_edit\" in request.form:\n if request.form['name']:\n editedCategory.name = request.form['name']\n flash('Category Successfully Edited %s' %\n editedCategory.name)\n return redirect(url_for('showCategories'))\n else:\n return redirect(url_for('showCategories'))\n else:\n return redirect(url_for('showCategories'))\n else:\n return render_template('editCategory.html',\n category=editedCategory,\n user=getUserInfo(login_session['user_id']))","def update_category_item(catalog_item_id):\n edited_item = session.query(CatalogItem). \\\n filter_by(id=catalog_item_id).one()\n if request.form['name']:\n edited_item.name = request.form['name']\n if request.form['description']:\n edited_item.description = request.form['description']\n if request.form['price']:\n edited_item.price = request.form['price']\n session.add(edited_item)\n session.commit()","def edit_item(item_id):\n if 'userinfo' not in session.keys():\n session['target'] = url_for('edit_item', item_id=item_id)\n return redirect(url_for('gconnect'))\n if request.method == 'POST':\n sqlsession = SQLSESSION()\n item = sqlsession.query(Item).filter_by(id=item_id).first()\n item.name = request.form['name']\n item.category_id = request.form['category']\n item.description = request.form['description']\n sqlsession.commit()\n return redirect(url_for('view_item', item_id=item_id))\n sqlsession = SQLSESSION()\n item = sqlsession.query(Item).filter_by(id=item_id).first()\n categories = sqlsession.query(Category).all()\n return render_template(\"edit_item.html\",\n item=item,\n categories=categories)","def editCategory(category_id):\n\n edited_category = session.query(Category).filter_by(id=category_id).first()\n if edited_category.user_id != login_session['user_id']:\n flash(\"You are authorised to Edit category created by You only!\")\n\n return redirect(url_for(\"showCatalog\"))\n\n if request.method == 'POST':\n if request.form['name'] != '':\n edited_category.name = request.form['name']\n session.add(edited_category)\n session.commit()\n flash('Category Successfully Edited %s' % edited_category.\n name)\n return redirect(url_for('showCatalog'))\n else:\n flash(\"Error editing category!\")\n return render_template('editCategory.html',\n category=edited_category)\n else:\n return render_template('editcategory.html',\n category=edited_category)","def editCategory(category_id):\r\n # authentication\r\n if 'username' not in login_session:\r\n flash('Please login to edit category')\r\n return redirect(url_for('showCategories'))\r\n\r\n # validation\r\n editedCategory = session.query(Category).filter_by(id=category_id).first()\r\n if not editedCategory:\r\n flash('Attempt to edit non-existent category')\r\n return redirect(url_for('showCategories'))\r\n\r\n # authorization\r\n if login_session['user_id'] != editedCategory.user_id:\r\n flash('Sorry, you are not authorized to edit the category \\'{}\\''\r\n .format(editedCategory.name))\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n if request.method == 'POST':\r\n # update operation\r\n if request.form['name']:\r\n editedCategory.name = request.form['name']\r\n\r\n if request.form['description']:\r\n editedCategory.description = request.form['description']\r\n else:\r\n editedCategory.description = ''\r\n session.add(editedCategory)\r\n session.commit()\r\n flash('Edited Category \\'{}\\' Successfully'.format(\r\n editedCategory.name))\r\n return redirect(url_for('showItems', category_id=category_id))\r\n else:\r\n # serve GET requests with form\r\n return render_template(\"editCategory.html\", category=editedCategory)","def edit_category(self, category_id, name, user_id):\r\n category = self._db_manager.get_category(category_id)\r\n if category is None:\r\n flash(\"Invalid category.\")\r\n return\r\n if category[\"user_id\"] != user_id:\r\n flash(\"Only the original creator can edit a category.\")\r\n return\r\n flash(self._db_manager.edit_category(category_id, name))","def edit_category(category_id):\n\n category = Category.query.filter(\n Category.id == category_id,\n Category.user_id == current_user.id\n ).first()\n\n if not category:\n flash(\"Couldn't find that category\", category='warning')\n return redirect(request.referrer)\n\n form = CategoryForm()\n form.name.current_user_id = current_user.id\n\n if form.validate_on_submit():\n category.name = form.name.data.capitalize()\n db.session.commit()\n flash('Successfully updated category', 'success')\n return redirect(url_for('url.index'))\n\n elif request.method == 'GET':\n form.name.data = category.name\n\n return render_template(\n 'forms/form.html',\n form_title='Edit Category',\n form=form,\n form_name='category',\n action=url_for('url.edit_category', category_id=category_id))","def newItem(category_id):\n editedCategory = session.query(Category). \\\n filter_by(id=category_id).one()\n if editedCategory.user_id != login_session['user_id']:\n flash('You are not authorized to edit this Category.\\\n Please create your own Category in order to edit.')\n return redirect(url_for('showCategory', category_id=category_id))\n if request.method == 'POST':\n newItem = Item(\n name=request.form['name'],\n description=request.form['description'],\n price=request.form['price'],\n category_id=category_id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Item created')\n return redirect(url_for('showCategory',\n category_id=category_id))\n else:\n return render_template('newItem.html', category_id=category_id)","def edit_category(category_name):\n\n category = Category.query.filter_by(name=category_name).first_or_404()\n\n if category.owner != current_user:\n flash(\"Failed to edit category %s since you are not the owner.\" %\n category.name)\n return redirect(url_for('.index'))\n\n form = AddOrEditCategoryForm()\n if form.validate_on_submit():\n category.name = form.name.data\n try:\n db.session.commit()\n except:\n flash(\n (\"Failed to edit category \\\"%s\\\".\"\n \" Make sure that the category name is unique.\")\n % category.name)\n else:\n flash(\"Category \\\"%s\\\" has been edited.\" % category.name)\n finally:\n return redirect(url_for('.index'))\n form.name.data = category.name\n return render_template('add_or_edit.html', form=form)","def editItem(category_id, item_id):\r\n if 'username' not in login_session:\r\n return redirect(url_for('showLogin'))\r\n session = DBSession()\r\n editedItem = session.query(Item).filter_by(id=item_id).one()\r\n if editedItem.user_id != login_session['user_id']:\r\n return \"<script>function myFunction() {alert('You are not authorized to edit this item.');}</script><body onload='myFunction()''>\"\r\n if request.method == 'POST':\r\n editedItem.name = request.form['name']\r\n session.add(editedItem)\r\n session.commit()\r\n return redirect(url_for('showCategoryItems', category_id=category_id))\r\n else:\r\n return render_template('edititem.html', category_id=category_id, item=editedItem)","def edit_item(item_id):\n\n item = Item.query.filter(\n Item.id == item_id,\n Item.user_id == current_user.id\n ).first()\n\n if not item:\n flash(\"Couldn't find a item with that id\", category='warning')\n return redirect(request.referrer)\n\n form = ItemForm()\n form.editting_item_id = item_id\n # Query for select field\n form.category_id.query = Category.query.filter(\n Category.user_id == current_user.id).all()\n\n if form.validate_on_submit():\n item.category_id = form.category_id.data.id\n item.name = form.name.data.capitalize()\n item.description = form.description.data\n db.session.commit()\n flash('Successfully updated Item', 'success')\n return redirect(url_for('url.index'))\n\n elif request.method == 'GET':\n form.name.data = item.name\n form.description.data = item.description\n\n return render_template(\n 'forms/form.html',\n form_title='Edit Item',\n form=form,\n form_name='item',\n action=url_for('url.edit_item', item_id=item_id))","def edit_item(item_name):\n\n item = Item.query.filter_by(name=item_name).first_or_404()\n\n if item.owner != current_user:\n flash(\"Failed to edit item %s since you are not the owner.\" %\n item.name)\n return redirect(url_for('.index'))\n\n form = AddOrEditItemForm(Category.query.order_by(Category.name).all())\n if form.validate_on_submit():\n\n img_upload_name = secure_filename(form.img_upload.data.filename)\n img_deletehash = None\n img_url = None\n\n # Delete uploaded image on Imgur\n if item.img_deletehash is not None \\\n and not delete_image(item.img_deletehash):\n flash(\"Failed to edit item \\\"%s\\\".\" % item.name)\n return redirect(url_for('.index'))\n\n # Upload new image on Imgur\n if img_upload_name != '':\n img_url, img_deletehash = upload_image(form.img_upload.data)\n print \"img_url: \" + img_url\n print \"img_deletehash: \" + img_deletehash\n if img_url is None or img_deletehash is None:\n flash(\"Failed to upload image.\")\n return redirect(url_for('.index'))\n\n elif form.img_url.data != '':\n img_url = form.img_url.data\n\n item.name = form.name.data\n item.description = form.description.data\n item.category = Category.query.get(form.category.data)\n item.img_url = img_url\n item.img_deletehash = img_deletehash\n\n try:\n db.session.commit()\n except:\n flash(\n (\"Failed to edit item \\\"%s\\\".\"\n \" Make sure that the item name is unique.\") % item.name)\n else:\n flash(\"Item \\\"%s\\\" has been edited.\" % item.name)\n finally:\n return redirect(url_for('.index'))\n\n form.name.data = item.name\n form.description.data = item.description\n form.category.data = item.category.id\n form.img_url.data = item.img_url\n\n return render_template('add_or_edit.html', form=form)","def edit_recipe_category(title):\n session['recipe_category_title'] = title\n if request.method == 'POST':\n result = USERS[session['username']].edit_recipe_category(session['recipe_category_title'],\n request.form['title'])\n if result == 'recipe_category edited':\n flash(result, 'info')\n else:\n flash(result, 'warning')\n return redirect(url_for('dashboard'))\n return render_template('edit_recipe_category.html')","def add_item():\n\n form = AddOrEditItemForm(Category.query.order_by(Category.name).all())\n img_upload_name = None\n if form.validate_on_submit():\n img_upload_name = secure_filename(form.img_upload.data.filename)\n img_deletehash = None\n img_url = None\n\n # Upload image to Imgur if FileField is specified\n if img_upload_name != '':\n img_url, img_deletehash = upload_image(form.img_upload.data)\n if img_url is None or img_deletehash is None:\n flash(\"Failed to upload image.\")\n return redirect(url_for('.index'))\n elif form.img_url.data != '':\n img_url = form.img_url.data\n\n new_item = Item(name=form.name.data, description=form.description.data,\n category=Category.query.get(form.category.data),\n img_url=img_url, img_deletehash=img_deletehash,\n owner=current_user._get_current_object())\n\n try:\n db.session.add(new_item)\n db.session.commit()\n except:\n flash(\n (\"Failed to add item \\\"%s\\\".\"\n \" Make sure that the item name is unique.\") % new_item.name)\n else:\n flash(\"A new item \\\"%s\\\" has been added.\" % new_item.name)\n finally:\n return redirect(url_for('.index'))\n\n # Set SelectField's default value\n category_name = request.args.get('category_name')\n if category_name is not None:\n default_category = Category.query.filter_by(name=category_name).first()\n if default_category is None:\n flash(\"Wrong parameter(s).\")\n return redirect(url_for('.index'))\n form.category.data = default_category.id\n\n return render_template('add_or_edit.html',\n form=form, filename=img_upload_name)","def editCategory(category_id):\r\n if 'username' not in login_session:\r\n return redirect(url_for('showLogin'))\r\n session = DBSession()\r\n editedCategory = session.query(Category).filter_by(id=category_id).one()\r\n if editedCategory.user_id != login_session['user_id']:\r\n return \"<script>function myFunction() {alert('You are not authorized to edit this category.');}</script><body onload='myFunction()''>\"\r\n if request.method == 'POST':\r\n editedCategory.name = request.form['name']\r\n session.add(editedCategory)\r\n session.commit()\r\n return redirect(url_for('showCategories'))\r\n else:\r\n return render_template('editcategory.html', category=editedCategory)","def test_edit_category(self):\n response = self.client.put('/api/v1/category/1',\n data=json.dumps(category[3]),\n content_type='application/json',\n headers=self.admin_headers)\n self.assertEqual(response.status_code, 201)\n self.assertIn('Apparels', str(response.data))","def update(self, request, *args, **kwargs):\n response = super(CategoryViewSet).update(self, request, *args, *kwargs)\n response.data['message'] = \"Categoria ha sido editada\"","def update_item(item_id):\n edited_item = session.query(Item).filter_by(id=item_id).one()\n\n # redirect to details page if current user does not own item\n if edited_item.user_id != login_session['user_id']:\n return redirect(\n url_for(\n 'item_details',\n category_id=edited_item.category_id,\n item_id=edited_item.id))\n\n if request.method == 'POST':\n if request.form['category']:\n edited_item.category_id = request.form['category']\n if request.form['name']:\n edited_item.name = request.form['name']\n if request.form['description']:\n edited_item.description = request.form['description']\n edited_item.updated_date = datetime.datetime.now()\n session.add(edited_item)\n session.commit()\n return redirect(\n url_for(\n 'item_details',\n category_id=edited_item.category_id,\n item_id=edited_item.id))\n else:\n categories = session.query(Category).all()\n return render_template(\n 'views/edit.html',\n edited_item=edited_item,\n categories=categories)","def editItem(sport_id, item_id):\n\n sport = session.query(Sport).filter_by(id=sport_id).one()\n editedItem = session.query(Item).filter_by(id=item_id).one()\n if request.method == 'POST':\n if request.form['name']:\n editedItem.name = request.form['name']\n if request.form['description']:\n editedItem.description = request.form['description']\n editedItem.user_id = login_session['user_id']\n session.add(editedItem)\n session.commit()\n return redirect(url_for('showCatalog', sport_id=sport_id))\n else:\n return render_template('edititem.html', sport_id=sport_id,\n item_id=item_id, sport=sport, item=editedItem)","def edit_category(category_id):\n if request.args.get('state') != login_session['state']:\n response = make_response(\n json.dumps({'error': 'Invalid state parameter.'}), 401\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n if 'username' not in login_session:\n response = make_response(\n json.dumps({'error': 'User is logged out. This should not happen'}), 401\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n try:\n if request.method == 'POST':\n category = session.query(Category).filter_by(id=category_id).all()\n if len(category) > 0:\n state = get_new_state()\n login_session['state'] = state\n category = category[0]\n category.name = request.form['name']\n session.add(category)\n session.commit()\n response = make_response(\n json.dumps({'success': '', 'nonce': login_session['state']}), 200\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n else:\n return make_response(jsonify(error=[\"No results found\"]), 404)\n except Exception as inst:\n print(type(inst))\n print(inst.args)\n print(inst)","def render_edit_item_page(\r\n self, client_id, state, user_id, user_name, item_id):\r\n categories = self._db_manager.get_category_list(user_id)\r\n if len(categories) == 0:\r\n flash(\"You have created no categories to add items to.\")\r\n return\r\n item = self._db_manager.get_item(item_id)\r\n if item is None:\r\n flash(\"Invalid item.\")\r\n return\r\n if item[\"user_id\"] != user_id:\r\n flash(\"Only the original creator can edit an item.\")\r\n return\r\n return render_template(\r\n \"item_edit.html\",\r\n client_id=client_id,\r\n state=state,\r\n is_logged_in=True,\r\n user_name=user_name,\r\n categories=categories,\r\n item=item\r\n )","def render_edit_category_page(\r\n self, client_id, state, user_id, user_name, category_id):\r\n category = self._db_manager.get_category(category_id)\r\n if category is None:\r\n flash(\"Invalid category.\")\r\n return\r\n if category[\"user_id\"] != user_id:\r\n # the check whether the user owns the category can only be made\r\n # here since the database needs to be consulted\r\n flash(\"Only the original creator can edit a category.\")\r\n return\r\n return render_template(\r\n \"category_edit.html\",\r\n client_id=client_id,\r\n state=state,\r\n is_logged_in=True,\r\n user_name=user_name,\r\n category=category\r\n )","def editConcept(self):\n if self.concept_list.currentIndex().isValid():\n concept = self.concept_list.selectedItems()[0].data(Qt.UserRole)[0]\n subcategory = self.concept_list.selectedItems()[0].data(Qt.UserRole)[1]\n dlg = EditConceptDialog(self, concept, subcategory)\n if dlg.exec_():\n concept, subcategory = dlg.getValue()\n self.db.update_concept(concept)\n self.db.update_subcategory(subcategory)\n self.search()","def update_item_page(item_name, catagory_name):\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\n catagories = [c.name for c in Catagory.fetch_all()]\n return render_template(\n 'edit_item.html',\n catagories=catagories,\n values={\n 'name': item.name,\n 'catagory': item.catagory_name,\n 'description': item.description\n },\n )","def edit(self, **kwargs):\n ...","def adminedit(object, id):\n\n db = get_db()\n\n if request.method == \"POST\":\n execute_string = 'UPDATE ' + object.title() + \" SET \"\n\n if object == 'post':\n execute_string += 'title = \"' + request.form['title'] + '\", content = \"' + request.form['content'] + '\", authorId = ' + request.form[\"authorid\"] + ', categoryId = ' + request.form[\"categoryid\"] + ''\n elif object == 'author':\n execute_string += 'name = \"' + request.form['name'] + '\"'\n elif object == 'category':\n execute_string += 'name = \"' + request.form['name'] + '\", description = \"' + request.form['description'] + '\"'\n\n execute_string += \" WHERE id = \" + str(id)\n db.execute(execute_string)\n db.commit()\n return redirect(url_for(\"adminview\", object=object))\n\n execute_string = \"SELECT * FROM \" + object.title() + \" WHERE id = \" + str(id)\n item = db.execute(execute_string).fetchone()\n\n return render_template(\"new.html\", object=object, item=item)","def careerCatagory_edit(request):\r\n action = tool.get_param_by_request(request.GET, 'action', \"add\", str)\r\n page_index = tool.get_param_by_request(request.GET, 'page_index', 1, int)\r\n\r\n careerCatagory = None\r\n if action == \"edit\" or action == \"show\":\r\n _id = tool.get_param_by_request(request.GET, 'id', 0, int)\r\n careerCatagory = api_careerCatagory.get_career_catagory_by_id(_id)\r\n\r\n if careerCatagory.is_error():\r\n return render_to_response(\"404.html\", {}, context_instance=RequestContext(request))\r\n\r\n careerCatagory = careerCatagory.result()[0]\r\n\r\n c = {\"careerCatagory\": careerCatagory, \"action\": action, \"page_index\": page_index}\r\n\r\n return render_to_response(\"mz_course/careerCatagory_save.html\", c, context_instance=RequestContext(request))","def edit(self,item=None):\r\n raise AbstractError\r\n return False","def test_edit_category(self):\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\n self.login('Bo_theo5@example.com', 'Bo1995')\n self.dashboard()\n self.category('Breakfast')\n self.dashboard()\n rv = self.edit_category('JunkFood')\n self.assertIn(b'Category successfully updated', rv.data)","def test_edit_non_existing_item(self):\n response = self.client.put('/api/v1/category/200',\n data=json.dumps(category[3]),\n content_type='application/json',\n headers=self.admin_headers)\n self.assertEqual(response.status_code, 404)\n self.assertIn('category with id 200 does not exist',\n str(response.data))","def test_edit_category(self):\n rv = self.client().post(\n '/categories/',\n data={'category_name': 'Sauces'})\n self.assertEqual(rv.status_code, 201)\n rv = self.client().put(\n '/categories/1',\n data={\n \"name\": \"Soups and Sauces\"\n })\n #self.assertEqual(rv.status_code, 200)\n results = self.client().get('/categories/1')\n #self.assertIn('Soups and', str(results.data))","def update_item(item_name, catagory_name):\n try:\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\n except NoResultFound:\n abort(404)\n errors = form_errors(request.form)\n new_item_name = request.form.get('name')\n new_catagory_name = request.form.get('catagory')\n new_description = request.form.get('description')\n if errors:\n values = {\n 'name': new_item_name,\n 'catagory': new_catagory_name,\n 'description': new_description\n }\n catagories = [c.name for c in Catagory.fetch_all()]\n return render_template(\n 'add_item.html',\n catagories=catagories,\n values=values,\n errors=errors\n )\n item.update(\n name=new_item_name,\n catagory_name=new_catagory_name,\n description=new_description\n )\n return redirect(url_for(\n 'read_item', item_name=new_item_name, catagory_name=new_catagory_name\n ))","def newItem(category_id):\n category = session.query(Category).filter_by(id=category_id).one()\n if request.method == 'POST':\n newItem = Item(name=request.form['name'],\n description=request.form['description'],\n price=request.form['price'], category_id=category.id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Item %s Successfully Created' % (newItem.name))\n return redirect(url_for('showItem', category_id=category.id))\n else:\n return render_template('newitem.html', category_id=category.id)","def edit_item(request, item_id):\n if request.user.is_superuser:\n item = get_object_or_404(Product, pk=item_id)\n if request.method == \"POST\":\n form = ProductForm(request.POST, request.FILES, instance=item)\n if form.is_valid():\n form.save()\n messages.success(request, 'Item was successfully updated.')\n return redirect(reverse('item_info', args=[item.id]))\n else:\n messages.error(request, 'There was an issue updating the '\n 'item. Please make sure the form is valid.')\n else:\n form = ProductForm(instance=item)\n else:\n messages.error(request, 'Sorry, you do not have permission to access '\n 'this page.')\n return redirect(reverse('home'))\n\n template = 'shop/edit_item.html'\n context = {\n 'form': form,\n 'item': item,\n }\n\n return render(request, template, context)","def update(self, request, pk=None):\n current_user = User.objects.get(id=request.user.id)\n if current_user.is_staff:\n try:\n category = Category.objects.get(pk=pk)\n except Category.DoesNotExist:\n return Response({\"reason\": \"Doesn't Exist\"}, status=status.HTTP_400_BAD_REQUEST)\n category.label = request.data['label']\n category.approved = False\n try:\n category.save()\n return Response({}, status=status.HTTP_204_NO_CONTENT)\n except ValidationError as ex:\n return Response({\"reason\": ex.message}, status=status.HTTP_400_BAD_REQUEST)\n else:\n return Response({'message': \"*Sigh*, you're not changing a thing, non-admin\"},\n status=status.HTTP_403_FORBIDDEN)","def newListItem(category_id):\n\n if 'username' not in login_session:\n return redirect('/login')\n\n category = session.query(Category).filter_by(id=category_id).one()\n\n if category.user_id != login_session['user_id']:\n flash('You are not the creator of %s category, and cannot modify it' %\n category.name)\n return redirect(url_for('showItems', category_id=category.id))\n if request.method == 'POST':\n if \"btn_new\" in request.form:\n newItem = ListItem(name=request.form['name'],\n description=request.form['description'],\n category_id=category_id,\n user_id=login_session['user_id'])\n session.add(newItem)\n session.commit()\n flash('New Catalog Item: %s Successfully Created' % (newItem.name))\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return render_template('newitem.html',\n category_id=category_id,\n user=getUserInfo(login_session['user_id']))","def editDetail(id):\n form = EditDetailForm(request.form)\n if request.method == \"GET\":\n return render_template(\"/pages/edit.html\", form=form)\n else:\n choose = True\n section = form.category.data\n return redirect(url_for(\"editDetailSection\", id=id ,section=section))","def display_item(categories, item, item_id, initial_category_id):\n if item:\n # Item already exists - display on page\n return render_template('item_edit.html', item_id=item_id, item_name=item.Item.name,\n item_description=item.Item.description, item_category=item.Item.category,\n item_category_id=item.Item.category_id, categories=categories,\n login_session=login_session,\n csrf_token=generate_csrf_token())\n else:\n print('initial_category_id', initial_category_id)\n # Default fields for creating a new item\n return render_template('item_edit.html', item_id=0, item_name=\"\",\n item_description=\"\", item_category=\"\",\n item_category_id=initial_category_id, categories=categories,\n login_session=login_session, initial_category_id=initial_category_id,\n csrf_token=generate_csrf_token())","def deleteCategory(category_id):\n editedCategory = session.query(Category).\\\n filter_by(id=category_id).one()\n editedItem = session.query(Item).\\\n filter_by(category_id=editedCategory.id).all()\n print editedItem\n if editedCategory.user_id != login_session['user_id']:\n flash('You are not authorized to delete this Item.\\\n Please create own Category with items in order to \\\n delete items.')\n return redirect(url_for('showallCategories'))\n else:\n if editedItem:\n flash('Category Deletion not possible. \\\n Please delete the items in Category')\n return redirect(url_for('showCategory',\n category_id=category_id))\n elif request.method == 'POST':\n session.delete(editedCategory)\n session.commit()\n flash('Category Deletion successfull')\n return redirect(url_for('showallCategories'))\n else:\n return render_template(\n 'deleteCategory.html', category_id=category_id,\n category=editedCategory)","def edit_entry():\n if not check_admin_logged() :\n abort(403)\n\n title = request.form['title']\n category = request.form['category']\n buydate = request.form['buydate']\n ssid = decrypt_book_record(request.form['ssid'])\n\n if not check_items_in_form(title, category, buydate):\n return redirect(url_for('show_entries_admin'))\n\n edited_entry = Entries.query.filter_by(\n id=ssid, title=title, category=category, \\\n buydate=buydate).first()\n\n if edited_entry is not None :\n edited_entry.introduction = request.form['introduction']\n if db.session.is_modified(edited_entry) :\n # commit only if something is modified\n try :\n db.session.commit()\n except IntegrityError as e :\n log_error('error when edit:')\n log_error(e.message)\n flash(u'数据库操作失败导致更新失败！请看后台日志')\n flash(u'成功更新条目')\n\n return redirect(url_for('show_entries_admin'))","def edit_category(self, category_id, category_name, parent_id):\n # [todo] - all parameters except category_id optional, fill others with\n # current values\n\n # [todo] - validate category_id\n # [todo] - validate new values\n\n # open a cursor\n cur = self.get_cursor()\n\n stmt = \"UPDATE categories \" + \\\n \"SET parent_id='{0}', \".format(parent_id) + \\\n \"category_name='{0}' \".format(category_name) + \\\n \"WHERE category_id={0}\".format(category_id)\n\n cur.execute(stmt)\n\n # close the cursor\n self.close_cursor()","def edit_recipe(description):\n session['description']=description\n if request.method == 'POST':\n des_result=(USERS[session['username']].recipe_category[session['current_recipe_category_title']].\n update_description(session['description'], request.form['description']))\n status_result=(USERS[session['username']].recipe_category[session['current_recipe_category_title']].\n update_status(session['description'], request.form['status']))\n if des_result == 'recipe updated' or status_result == 'recipe updated':\n flash('recipe updated', 'info')\n else:\n flash(des_result, 'warning')\n return redirect(url_for('edit_recipe', recipe_category_title=session['current_recipe_category_title']))\n return render_template('edit_recipe.html', item=USERS[session['username']]\n .recipe_category[session['current_recipe_category_title']].recipes[description],\n recipes=USERS[session['username']].\n recipe_category[session['current_recipe_category_title']].recipes)","def edit(item_id):\n session = current_app.config['db']\n item = session.query(WineABV).filter_by(id=item_id).one()\n if request.method == \"POST\":\n new_name = request.form['itemname']\n item.name = new_name\n try:\n session.commit()\n except exc.IntegrityError:\n session.rollback()\n flash(\"Duplicate values!\", 'danger')\n return render_template('edit_form.html', item=item)\n\n flash(\"Successfully Edited '%s'\" % (new_name,), 'success')\n return redirect(url_for('.show'))\n else:\n return render_template(template_prefix+'edit_form.html', item=item)","def edit(self):\n\n pass","def edit_item(action, user):\n def get_item(items, id):\n for item in items:\n if item.id == id:\n return item \n raise Item.DoesNotExist()\n \n l = List.objects.get(id=action.get('listId', None))\n verify_permission(l, user)\n \n editable_attributes = ('position', 'description', 'crossed')\n \n try:\n item = get_item(l.items, action['what']['id'])\n except:\n raise Item.DoesNotExist\n \n for key, value in action['what'].iteritems():\n if key == 'id': continue\n elif key in editable_attributes:\n item.__setattr__(key, value)\n l.save()\n \n return l","def newItem():\n if request.method == 'POST':\n db.createItem(\n title=request.form['title'],\n description=request.form['description'],\n category_id=request.form['category'],\n user_id=login_session['user_id'])\n flash(\"New catalog item created!\", 'success')\n return redirect(url_for('showCatalog'))\n return render_template('new_item.html', categories=db.getAllCategories())","def edit(self, *args, **kw):\n id_tipo_item = UrlParser.parse_id(request.url, \"tipositems\")\n url_action = \"../\"\n \n pp = PoseePermiso('redefinir tipo item',\n id_tipo_item=id_tipo_item)\n if not pp.is_met(request.environ):\n flash(pp.message % pp.nombre_permiso, 'warning')\n redirect(url_action)\n tmpl_context.widget = self.edit_form\n value = self.edit_filler.get_value( \\\n values={'id_atributos_por_tipo_item': int(args[0])})\n value['_method'] = 'PUT'\n page = \"Atributo {nombre}\".format(nombre=value[\"nombre\"])\n return dict(value=value, \n page=page, \n atras=url_action)","def update(self, request, pk=None):\n if not request.auth.user.is_staff:\n return Response(\n {'message': 'You must be an admin to update categories.'},\n status=status.HTTP_403_FORBIDDEN\n )\n\n # Do mostly the same thing as POST, but instead of\n # creating a new instance of Category, get the Category record\n # from the database whose primary key is `pk`\n category = Categories.objects.get(pk=pk)\n category.label = request.data[\"label\"]\n \n\n category.save()\n\n # 204 status code means everything worked but the\n # server is not sending back any data in the response\n return Response({}, status=status.HTTP_204_NO_CONTENT)","def edit_item(item_name):\n item = Item.query.filter_by(name=item_name).first()\n\n # If the URL contains a bad item name, send a 404\n if not item:\n abort(404)\n\n # If the current user is not authorized to edit the item because\n # the item was created by a different user, send a 403\n elif current_user != item.user:\n abort(403)\n\n form = ItemForm()\n\n # If the form is validated, update the item with its data to the\n # database\n if form.validate_on_submit():\n\n # If the item name or sport has been modified, check that an\n # item with the same name and sport does not already exist, or\n # send a flash message and do not add the new item to the\n # database\n if form.name.data != item.name or form.sport.data != item.sport:\n query = Item.query.filter_by(name=form.name.data,\n sport=form.sport.data).first()\n if query:\n flash('This sport already has an item with that name.', 'bad')\n return redirect(url_for('items.edit_item',\n item_name=item_name))\n\n # If the item name or sport has not been modified, update all\n # details to the database, send a flash message, and redirect\n # to 'home'\n else:\n item.name = form.name.data\n item.sport = form.sport.data\n item.category = form.category.data\n item.description = form.description.data\n item.private = form.private.data\n db.session.commit()\n flash(f'\"{item.name}\" has been updated!', 'good')\n return redirect(url_for('items.item', item_name=item_name))\n\n # If the form is being requested, not submitted, pre-fill the form\n # with existing item data\n elif request.method == 'GET':\n form.name.data = item.name\n form.sport.data = item.sport\n form.category.data = item.category\n form.description.data = item.description\n form.private.data = item.private\n\n return render_template('edit_item.html', item=item, form=form)","def item_update(request):\n if request.method == 'POST':\n item_to_update = get_object_or_404(StockItem, pk=request.POST['id'])\n item_to_update.name = request.POST['name']\n item_to_update.count = int(request.POST['count'])\n item_to_update.date_of_expiration = request.POST['exp']\n item_to_update.fk_category = Category.objects.get(name=request.POST['cat'])\n item_to_update.fk_subcategory = SubCategory.objects.get(name=request.POST['subcat'])\n item_to_update.notes = request.POST['notes']\n item_to_update.save()\n return HttpResponse(status=200)","def new_item():\n if request.method == 'POST':\n new_item = Item(\n category_id=int(request.form['category']),\n name=request.form['name'],\n description=request.form['description'],\n created_date=datetime.datetime.now(),\n user_id=login_session['user_id'])\n session.add(new_item)\n session.commit()\n return redirect(\n url_for(\n 'item_details',\n category_id=new_item.category_id,\n item_id=new_item.id))\n else:\n categories = session.query(\n Category).all()\n return render_template(\n 'views/add.html',\n categories=categories)","def edit_seo(request, category_id, template_name=\"manage/category/seo.html\"):\n category = lfs_get_object_or_404(Category, pk=category_id)\n\n if request.method == \"POST\":\n form = SEOForm(instance=category, data=request.POST)\n if form.is_valid():\n form.save()\n message = _(u\"SEO data has been saved.\")\n else:\n message = _(u\"Please correct the indicated errors.\")\n else:\n form = SEOForm(instance=category)\n\n seo_html = render_to_string(template_name, RequestContext(request, {\n \"category\": category,\n \"form\": form,\n }))\n\n if request.is_ajax():\n return HttpResponse(simplejson.dumps({\n \"seo\": seo_html,\n \"message\": message,\n }, cls=LazyEncoder))\n else:\n return seo_html","def transaction_edit(request, transaction_id, model_class=Transaction, form_class=TransactionForm, template_name='budget/transactions/edit.html'):\n transaction = get_object_or_404(model_class.active.all(), pk=transaction_id)\n if request.POST:\n form = form_class(request.POST, instance=transaction)\n \n if form.is_valid():\n category = form.save()\n return HttpResponseRedirect(reverse('budget_transaction_list'))\n else:\n form = form_class(instance=transaction)\n return render_to_response(template_name, {\n 'transaction': transaction,\n 'form': form,\n }, context_instance=RequestContext(request))","def update_recipe_category(db_id):\r\n\r\n # validates request form\r\n form = request.form\r\n error_list = validate_form(form, 'recipe_category')\r\n\r\n if error_list == []:\r\n # validates image URL\r\n image_URL = validate_image(form['img_link'])\r\n\r\n # keeps the old category name in case of change\r\n previous_name = mongo.db.recipe_categories.find_one(\r\n {'_id': ObjectId(db_id)})['name']\r\n\r\n # updates recipe category\r\n mongo.db.recipe_categories.update(\r\n {'_id': ObjectId(db_id)}, {'$set': {\r\n 'name': request.form.get('name'),\r\n 'img_link': image_URL}\r\n }\r\n )\r\n\r\n # updates the category name to the new one in the correspondent recipes\r\n\r\n mongo.db.recipes.update_many({'category': previous_name}, {'$set': {\r\n 'category': request.form.get('name')}}\r\n )\r\n\r\n # redirects to the recipe category search\r\n return redirect(url_for('search', collection='recipe_categories'))\r\n\r\n else:\r\n # initializes page title and header\r\n page_title = 'Update recipe category'\r\n page_header = 'Update a recipe category:'\r\n\r\n # sends error list back to the form to correct mistakes\r\n return render_template(\r\n 'edit_form.html',\r\n recipe_category=mongo.db.recipe_categories.find_one(\r\n {'_id': ObjectId(db_id)}),\r\n errors=error_list,\r\n form=form,\r\n page_title=page_title,\r\n page_header=page_header\r\n )","def add_category():\n\n form = AddOrEditCategoryForm()\n if form.validate_on_submit():\n new_category = Category(name=form.name.data, owner=current_user._get_current_object())\n try:\n db.session.add(new_category)\n db.session.commit()\n except:\n flash(\n (\"Failed to add category \\\"%s\\\".\"\n \" Make sure that the category name is unique.\")\n % new_category.name)\n else:\n flash(\"A new category \\\"%s\\\" has been added.\" % new_category.name)\n finally:\n return redirect(url_for('.index'))\n return render_template('add_or_edit.html', form=form)","def edit_recipe(recipe_id):\n if request.method == \"POST\":\n submit = {\n \"category_name\": request.form.get(\"category_name\"),\n \"recipe_name\": request.form.get(\"recipe_name\"),\n \"recipe_description\": request.form.get(\"recipe_description\"),\n \"recipe_ingredients\": request.form.get(\"recipe_ingredients\"),\n \"recipe_makes_for\": request.form.get(\"recipe_makes_for\"),\n \"due_time\": request.form.get(\"due_time\"),\n \"recipe_image\": request.form.get(\"recipe_image\"),\n \"created_by\": session[\"user\"]\n }\n mongo.db.recipes.update({\"_id\": ObjectId(recipe_id)}, submit)\n flash(\"Recipe Successfully Updated\")\n return redirect(url_for(\"recipes\"))\n\n recipe = mongo.db.recipes.find_one({\"_id\": ObjectId(recipe_id)})\n categories = mongo.db.categories.find().sort(\"category_name\", 1)\n return render_template(\n \"edit_recipe.html\", recipe=recipe, categories=categories)","def edit_item(request, product_id):\n\n if not request.user.is_superuser:\n messages.error(request, 'Sorry, you are not permitted to do that.')\n return redirect(reverse('home'))\n\n product = get_object_or_404(Product, pk=product_id)\n if request.method == 'POST':\n form = ProductForm(request.POST, request.FILES, instance=product)\n if form.is_valid():\n form.save()\n messages.success(request, 'You have successfully updated store item!')\n return redirect(reverse('home'))\n else:\n messages.error(request, 'Failed to update item. Please check the form.')\n else:\n form = ProductForm(instance=product)\n messages.info(request, f'You are editing {product.name}')\n\n template = 'products/edit_item.html'\n context = {\n 'form': form,\n 'product': product,\n }\n\n return render(request, template, context)","def editProfile():\n form = EditProfileForm(request.form)\n if request.method == \"GET\":\n return render_template(\"/pages/editprofile.html\", form=form)\n else:\n choose = True\n section = form.category.data\n return redirect(url_for(\"editProfileSection\", section=section))","def createItem(category_id):\r\n if 'username' not in login_session:\r\n return redirect(url_for('showLogin'))\r\n if request.method == 'POST':\r\n session = DBSession()\r\n item = Item(name=request.form['name'],\r\n description=request.form['description'],\r\n category_id=category_id,\r\n user_id=login_session['user_id'])\r\n session.add(item)\r\n session.commit()\r\n return redirect(url_for('showCategoryItems', category_id=category_id))\r\n else:\r\n return render_template('newitem.html', category_id=category_id)","def edit_item(item_id):\n if 'username' not in login_session:\n response = make_response(\n json.dumps({'error': 'User is logged out. This should not happen'}), 401\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n try:\n if request.method == 'POST':\n item = session.query(Item).filter_by(id=item_id).one()\n item.picture = request.form['picture']\n item.name = request.form['name']\n item.price = request.form['price']\n item.description = request.form['description']\n item.user_id = login_session['user_id']\n session.add(item)\n session.commit()\n response = make_response(\n json.dumps({'success': '', 'nonce': login_session['state']}), 200\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n except Exception as inst:\n print(type(inst))\n print(inst.args)\n print(inst)","def addItem(category_id):\r\n # authentication\r\n if 'username' not in login_session:\r\n flash('Please login to add item')\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n # validation\r\n category = session.query(Category).filter_by(id=category_id).first()\r\n if not category:\r\n flash('Attempted operation on non-existent category')\r\n return redirect(url_for('showCategories'))\r\n\r\n if request.method == 'POST':\r\n # create operation\r\n name = request.form['name']\r\n description = request.form['description']\r\n if not name:\r\n flash('Add ItemError: Name can\\'t be empty')\r\n return redirect(url_for('showItems', category_id=category_id))\r\n newItem = Item(name=name, description=description,\r\n category_id=category_id, user_id=category.user_id)\r\n session.add(newItem)\r\n session.commit()\r\n flash('Added Item \\'{}\\' Successfully!'.format(newItem.name))\r\n return redirect(url_for('showItems', category_id=category_id))\r\n else:\r\n # serve GET requests with the form\r\n return render_template(\"addItem.html\", category=category)","def test_category_mixed_on_edit(self):\n self.go200('minus_upload')\n self.formfile('minus_upload', 'file', AUDIO_FILE)\n self.fv('minus_upload', 'categories', 'onecat')\n self.submit200()\n minus = MinusRecord.objects.all()[0]\n self.assert_equal(minus.categories.count(), 1)\n self.go200('minus_edit', [self.superuser, minus.id])\n self.fv('minus_upload', 'add_category', 'yuppie')\n self.submit200()\n self.assert_equal(minus.categories.count(), 2)\n self.assert_equal(minus.categories.all()[0].name, 'onecat')\n self.assert_equal(minus.categories.all()[1].name, 'yuppie')","def test_edit(self):\n\n\t\titem_id = mock_item()[0]\n\n\t\titem_data = {'title': 'Item Two', 'author': 'Author Two',\n\t\t\t'location': 'Location Two'}\n\t\tmodels.edit(item_id, item_data)\n\n\t\titem = models.item(item_id)\n\n\t\tself.assertEqual(item['title'], item_data['title'])\n\t\tself.assertEqual(item['author'], item_data['author'])\n\t\tself.assertEqual(item['location'], item_data['location'])","def test_edit_recipe_category(self):\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\n self.login('Bo_theo5@example.com', 'Bo1995')\n self.dashboard()\n self.category('JunkFood')\n self.dashboard()\n self.recipe_dashboard()\n self.create_recipe('cakes', 'blah, blah, blah....mix ingredient, heat')\n rv = self.edit_recipe('edited cakes', 'edited blah blah blah spoon , heat')\n self.assertIn(b'Recipe successfully updated', rv.data)","def deleteItem(category_id, item_id):\n editedItem = session.query(Item).filter_by(id=item_id).one()\n if editedItem.user_id != login_session['user_id']:\n flash('You are not authorized to delete this Item.\\\n Please create own Category with items in order to \\\n delete items.')\n return redirect(url_for('showallCategories'))\n if request.method == 'POST':\n session.delete(editedItem)\n session.commit()\n flash('Item Deletion successfull')\n return redirect(url_for('showCategory', category_id=category_id))\n else:\n return render_template(\n 'deleteItem.html', category_id=category_id,\n item_id=item_id, item=editedItem)","def add_item():\n\n form = ItemForm()\n # Query for select field\n form.category_id.query = Category.query.filter(\n Category.user_id == current_user.id).all()\n\n if form.validate_on_submit():\n new_item = Item(\n category_id=form.category_id.data.id,\n name=form.name.data.capitalize(),\n description=form.description.data,\n user_id=current_user.id)\n db.session.add(new_item)\n db.session.commit()\n flash(\"New item '{}' was successfully created\".format(\n form.name.data.capitalize()), category='success')\n return redirect(url_for('url.index'))\n\n return render_template(\n 'forms/form.html',\n form_title='Add Item',\n form=form,\n form_name='item',\n action=url_for('url.add_item'))","def newItem():\n if request.method == 'POST':\n if not checkLogin():\n return requests(url_for('catelog'))\n\n if request.form['name'].strip() == '':\n flash('item create failed: name is empty!')\n return redirect(url_for('newItem'))\n\n category = session.query(\n Category).filter_by(\n name=request.form['category']).one()\n\n ifCategory = session.query(Category).filter_by(\n name=request.form['category']).one()\n ifItem = session.query(Item).filter_by(\n category_id=ifCategory.id,\n name=request.form['name']).all()\n if (len(ifItem) > 0):\n flash('item create failed: item(%s) \\\n is already exist in category(%s)' % (\n ifItem[0].name,\n ifCategory.name))\n return redirect(url_for('catelog'))\n\n newItem = Item(\n name=request.form['name'],\n description=request.form['description'],\n category=category,\n auth=getLoginUser(),\n time=getIntTime())\n session.add(newItem)\n session.commit()\n\n flash('new item created: %s' % newItem.name)\n\n return redirect(url_for(\n 'itemDetail',\n category_name=category.name,\n item_name=newItem.name))\n else:\n all_category = session.query(Category).all()\n return render_template(\n 'new-item.html',\n all_category=all_category,\n isLogin=checkLogin())","def edit(slug):\n entry = get_object_or_404(Entry, Entry.slug == slug)\n if request.method == 'POST':\n if request.form.get('title'):\n entry.title = request.form.get('title')\n if request.form.get('content'):\n entry.content = request.form.get('content')\n entry.published = request.form.get('published') or False\n entry.save()\n\n flash('Entry saved successfully!', 'success')\n if entry.published:\n return redirect(url_for('detail', slug=entry.slug))\n else:\n return redirect(url_for('edit', slug=entry.slug))\n return render_template('edit.html', entry=entry)","def menu_item_edit(restaurant_id, menu_id):\n # If the user isn't logged in, send to the login page\n if helper.handle_login(login_session) is False:\n return redirect('/login')\n\n restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()\n menu_item = session.query(MenuItem).filter_by(id=menu_id).one()\n if request.method == 'POST':\n if len(request.form['price']) > 0:\n if '$' in request.form['price']:\n menu_item.price = request.form['price']\n else:\n menu_item.price = '$' + request.form['price']\n if len(request.form['description']) > 0:\n menu_item.description = request.form['description']\n if 'course' in request.form:\n menu_item.course = request.form['course']\n if 'file' in request.files:\n img_id = helper.create_new_image_if_not_exists(file=request.files['file'],\n title=request.form['img_name'])\n if img_id != -1:\n menu_item.image_id = img_id\n session.add(menu_item)\n session.commit()\n flash(\"Menu item {} edited!\".format(menu_item.name))\n return redirect(url_for('restaurant_menu', restaurant_id=restaurant_id))\n else:\n user_info = helper.get_user_if_exists(login_session)\n return render_template('editmenu.html',\n restaurant=restaurant,\n menu_item=menu_item,\n user_info=user_info)","def edit():","def create_item():\n name = request.form['name']\n catagory = request.form['catagory']\n description = request.form['description']\n errors = form_errors(request.form)\n if errors:\n catagories = [c.name for c in Catagory.fetch_all()]\n values = {\n 'name': name, 'catagory': catagory, 'description': description\n }\n return render_template(\n 'add_item.html',\n catagories=catagories,\n values=values,\n errors=errors\n )\n Item.create(name, catagory_name=catagory, description=description)\n return redirect(url_for(\n 'read_item', catagory_name=catagory, item_name=name\n ))","def test_update_category(self):\n pass","def editPost(self, id, useRawHTML):\n old_data = self._extractPost(id)\n print\n content, publish = self._fillPost(useRawHTML, old_data)\n\n # Upload to server\n try :\n self.server.metaWeblog.editPost(\n id, self.username, self.password,\n content, publish\n )\n if raw_input(\"Change category ?[y|N] \") == \"y\" :\n self._setCategorie(id)\n except xmlrpclib.Fault as fault:\n display_XMLRPC_errors(\"edit entry\", fault)","def edit_item(self, item_id, transaction_id, description, amount,\n category_id):\n # [todo] - all parameters except item_id optional, fill others with\n # current values\n\n # [todo] - validate item_id\n # [todo] - validate new values\n\n # open a cursor\n cur = self.get_cursor()\n\n stmt = \"UPDATE transaction_items \" + \\\n \"SET transaction_id='{0}', \".format(transaction_id) + \\\n \"description='{0}', \".format(description) + \\\n \"amount='{0}', \".format(amount) + \\\n \"category_id='{0}' \".format(category_id) + \\\n \"WHERE transaction_item_id={0}\".format(item_id)\n\n cur.execute(stmt)\n\n # close the cursor\n self.close_cursor()","def put(self):\n request = transforms.loads(self.request.get('request'))\n\n if not self.assert_xsrf_token_or_fail(\n request, 'add-new-category', {}):\n return\n\n if not roles.Roles.is_super_admin():\n transforms.send_json_response(\n self, 401, 'Access denied.')\n return\n\n payload = request.get('payload')\n updated_dict = transforms.json_to_dict(\n transforms.loads(payload), self.get_schema_dict())\n\n errors = []\n self.apply_updates(updated_dict, errors)\n if not errors:\n transforms.send_json_response(self, 200, 'Saved.')\n else:\n transforms.send_json_response(self, 412, '\\n'.join(errors))","def EditLabel(self, item):\r\n \r\n self.Edit(item)","def clean_category(self):\n category = self.cleaned_data.get('category', None)\n # Used in the view\n self.category = category\n self.category_slug = slugify(category)\n\n categories = self.instance.categories\n\n # delete the old original category if present\n if self.original_category not in categories:\n # add\n if category is None:\n raise forms.ValidationError('Category cannot be None')\n else:\n # append new cat if not None\n categories.append(category)\n self.message = self.added_message.format(category=category)\n else:\n # edit\n categories.remove(self.original_category)\n # set the message\n self.message = self.modified_message.format(original_category=self.original_category, category=category)\n\n # set the instance categories to our updated\n # ensure uniquness by convert to set then back to list\n # cant use set as set loses sort order which is important here\n self.instance.categories = categories\n\n return category","def edit_item(self) -> None:\n item = self.get_selected_item(self.tree_cache)\n if item is None:\n return\n\n text, ok = QInputDialog.getText(self, \"Edit data\", \"Data:\", text=item.data().get_value())\n if ok:\n item.setText(text)\n item.data().set_value(text)","def edit_recipe(request, recipe, **_kwargs):\n return edit_view(request, _(\"Recipe\"), RecipeForm, recipe)","def edit_items(request):\n token = getToken(request)\n superUser = isSuperUser(token)\n if superUser == True:\n id = request.data['id']\n try:\n items = Items.objects.get(id=id)\n except:\n return Response(status=status.HTTP_404_NOT_FOUND)\n serializer = ItemsSerializer(items, data=request.data)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data)\n else:\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\n else:\n return Response(status=status.HTTP_401_UNAUTHORIZED)","def edit_item(self):\n for item in self.selection():\n origin_name = self.set(item)[\"1\"]\n origin_url = self.set(item)[\"2\"]\n popup = GetItemURLDialogue(self, \"Edit Item\", origin_name, origin_url)\n\n self.item(item, values=(popup.name, popup.url, self.set(item)[\"3\"]))\n self.set(item)[\"2\"] = popup.url\n\n # Edit the item - backend\n for row in s.item:\n if row[\"item\"] == origin_name and row[\"url\"] == origin_url:\n s.item.remove(row)\n s.updateItem({\"item\": popup.name, \"url\": popup.url})","def put(self):\n request = transforms.loads(self.request.get('request'))\n\n if not self.assert_xsrf_token_or_fail(\n request, 'update-category', {}):\n return\n\n if not roles.Roles.is_super_admin():\n transforms.send_json_response(\n self, 401, 'Access denied.')\n return\n\n payload = request.get('payload')\n updated_dict = transforms.json_to_dict(\n transforms.loads(payload), self.get_schema_dict())\n\n errors = []\n self.apply_updates(updated_dict, errors)\n if not errors:\n transforms.send_json_response(self, 200, 'Saved.')\n else:\n transforms.send_json_response(self, 412, '\\n'.join(errors))","def updateCategory(request, category_id):\n try:\n category = Category.objects.get(id=category_id)\n print(\"id\", category)\n except Category.DoesNotExist:\n return Response({'message': \"requested category does not exist\"}, status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n serializer = CategorySerializer(category)\n return Response({\"data\": serializer.data}, status=status.HTTP_200_OK)\n\n elif request.method == \"PUT\":\n serializer = CategorySerializer(category, data=request.data)\n if serializer.is_valid():\n serializer.save()\n return Response(\n {'data': serializer.data, \"message\": \"Data updated successfullt\", \"status\": status.HTTP_200_OK})\n else:\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def edit(self):\n if not self.context.model.is_editable():\n raise Unauthorized(\"Editing is not allowed\")\n\n title = self.request.get('title')\n if not title:\n return JSONResponse(self.request).error(\n _('agenda_item_update_empty_string',\n default=u\"Agenda Item title must not be empty.\")).proceed().dump()\n\n title = title.decode('utf-8')\n if self.agenda_item.has_proposal:\n if len(title) > ISubmittedProposal['title'].max_length:\n return JSONResponse(self.request).error(\n _('agenda_item_update_too_long_title',\n default=u\"Agenda Item title is too long.\")\n ).proceed().dump()\n\n self.agenda_item.set_title(title)\n return JSONResponse(self.request).info(\n _('agenda_item_updated',\n default=u\"Agenda Item updated.\")).proceed().dump()","def add_category():\n # Verify user login. If not, redirect to login page.\n login_status = None\n if 'email' in login_session:\n login_status = True\n else:\n flash('Please log in.')\n return redirect(url_for('home'))\n if request.method == 'POST':\n # Get form fields\n new_category_name = request.form['new_category_name']\n # Get user's database ID for the item's database entry\n user_db_id = (session.query(Users)\n .filter_by(email=login_session['email'])\n .one()).id\n print(\"Current user's database primary key id is {}.\"\n .format(user_db_id))\n # Flash messages for incomplete item info\n if not request.form['new_category_name']:\n flash('Please add category name.')\n return redirect(url_for('add_category'))\n # Query database for item name\n category_name_in_db = (session.query(Categories.name)\n .filter_by(name=new_category_name)\n .all())\n # If the category name is already in the database, don't add\n if category_name_in_db:\n print('Category name \"{}\" already in database.'\n .format(new_category_name))\n flash('Category name \"{}\" already in database.'\n .format(new_category_name))\n return redirect(url_for('add_category'))\n # If user is logged in, and all info provided, add category\n new_category = Categories(\n name=new_category_name,\n creator_db_id=user_db_id)\n session.add(new_category)\n session.commit()\n print('Category {} successfully created.'.format(new_category_name))\n # Return to homepage\n return redirect(url_for('home'))\n else:\n # Render webpage\n return render_template('add_category.html',\n login_status=login_status)","def edit_recipe(id):\n existing_recipe = mongo.db.recipes.find_one({\"_id\": ObjectId(id)})\n\n if request.method == \"POST\":\n recipe = recipe_parser(dict(request.form), session[\"user\"])\n mongo.db.recipes.update({\"_id\": ObjectId(id)}, recipe)\n return redirect(url_for(\"recipes\"))\n\n return render_template(\"recipes/edit.html\", recipe=existing_recipe)","def view_and_edit_listing(request, listing_id):\n categories = Category.objects.all()\n listing = get_object_or_404(Listing, pk=listing_id)\n\n if request.method == 'POST':\n editform = AddListingForm(\n request.POST,\n request.FILES,\n instance=listing)\n if editform.is_valid():\n listing.save()\n messages.success(\n request,\n 'Thank you. Your listing has been updated')\n return redirect(reverse('addlisting'))\n else:\n editform = AddListingForm(instance=listing)\n\n context = {\n 'editform': editform,\n 'listing': listing,\n 'categories': categories\n }\n return render(request, 'editlisting.html', context)","def setResourceCategory(self, resource_category_id, extraParams={}):\n import labstep.entities.resource.repository as resourceRepository\n\n return resourceRepository.editResource(\n self, resource_category_id=resource_category_id, extraParams=extraParams\n )","def put(self):\n request = transforms.loads(self.request.get('request'))\n key = self.request.get('key')\n\n if not self.assert_xsrf_token_or_fail(\n request, 'update-course-category', {'key': key}):\n return\n\n if not roles.Roles.is_super_admin():\n transforms.send_json_response(\n self, 401, 'Access denied.', {'key': self.KEY})\n return\n\n payload = request.get('payload')\n updated_dict = transforms.json_to_dict(\n transforms.loads(payload), self.get_schema_dict())\n\n errors = []\n self.apply_updates(updated_dict, errors)\n if not errors:\n transforms.send_json_response(self, 200, 'Saved.')\n else:\n transforms.send_json_response(self, 412, '\\n'.join(errors))","def restaurantMenuItemEdit(restaurant_id, menu_id):\n try:\n restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()\n menuItem = session.query(MenuItem).filter_by(id=menu_id).one()\n if request.method == 'POST':\n if request.form['name']:\n menuItem.name = request.form['name']\n if request.form['description']:\n menuItem.description = request.form['description']\n if request.form['price']:\n menuItem.price = request.form['price']\n if request.form['course']:\n menuItem.course = request.form['course']\n\n session.add(menuItem)\n session.commit()\n\n flash('Menu Item Successfully Edited', 'menu')\n return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id))\n else:\n return render_template('menuItemEdit.html', menuItem=menuItem, restaurant=restaurant)\n\n except exc.NoResultFound:\n return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id))","def set_category(request):\n try:\n # Update existing category if category_id exists, else create new Category\n if \"category_id\" not in request.POST or not request.POST[\"category_id\"]:\n # Create new Category\n category = Category.objects.create(title=request.form.cleaned_data[\"title\"])\n\n ActionLogger().log(request.user, \"created\", \"Knowledgebase Category %s\" % category)\n return format_ajax_response(True, \"Knowledgebase category created successfully.\")\n else:\n # Update existing category\n category = Category.objects.get(pk=request.POST[\"category_id\"])\n category.title = request.form.cleaned_data[\"title\"]\n category.save()\n\n ActionLogger().log(request.user, \"modified\", \"Knowledgebase Category %s\" % category)\n return format_ajax_response(True, \"Knowledgebase category updated successfully.\")\n except Exception as ex:\n logger.error(\"Failed to set_category: %s\" % ex)\n return format_ajax_response(False, \"There was an error setting the knowledgebase category.\")"],"string":"[\n \"def editItem(category_id, item_id):\\n editedItem = session.query(Item).filter_by(id=item_id).one()\\n category = session.query(Category).filter_by(id=category_id).one()\\n\\n if editedItem.user_id != login_session['user_id']:\\n flash(\\\"You are authorised to edit items created by you!\\\")\\n return redirect(url_for(\\\"showCatalog\\\"))\\n\\n if request.method == 'POST':\\n if request.form['name']:\\n editedItem.name = request.form['name']\\n if request.form['description']:\\n editedItem.description = request.form['description']\\n if request.form['price']:\\n editedItem.price = request.form['price']\\n session.add(editedItem)\\n session.commit()\\n flash('%s Item Successfully Edited' % (editedItem.name))\\n return redirect(url_for('showItem',\\n category_id=editedItem.category_id))\\n else:\\n return render_template('edititem.html', category=category,\\n item=editedItem)\",\n \"def editItem(category_id, item_id):\\n editedItem = session.query(Item).filter_by(id=item_id).one()\\n if editedItem.user_id != login_session['user_id']:\\n flash('You are not authorized to edit this Item.\\\\\\n Please create own Item in order to edit.')\\n return redirect(url_for('showallCategories'))\\n if request.method == 'POST':\\n if request.form['name']:\\n editedItem.name = request.form['name']\\n if request.form['description']:\\n editedItem.description = request.form['description']\\n if request.form['price']:\\n editedItem.price = request.form['price']\\n session.add(editedItem)\\n session.commit()\\n flash('Item Edit successfull')\\n return redirect(url_for('showCategory', category_id=category_id))\\n else:\\n return render_template(\\n 'editItem.html', category_id=category_id,\\n item_id=item_id, item=editedItem)\",\n \"def editListItem(category_id, item_id):\\n\\n if 'username' not in login_session:\\n return redirect('/login')\\n\\n editedItem = session.query(ListItem).filter_by(id=item_id).one()\\n category = session.query(Category).filter_by(id=category_id).one()\\n\\n if category.user_id != login_session['user_id']:\\n flash('You are not the creator of %s category, and cannot modify it' %\\n category.name)\\n return redirect(url_for('showItems', category_id=category.id))\\n\\n if request.method == 'POST':\\n if \\\"btn_edit\\\" in request.form:\\n if request.form['name']:\\n editedItem.name = request.form['name']\\n if request.form['description']:\\n editedItem.description = request.form['description']\\n session.add(editedItem)\\n session.commit()\\n flash('Catalog Item Successfully Edited')\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return render_template('edititem.html',\\n item=editedItem,\\n user=getUserInfo(login_session['user_id']))\",\n \"def edit_item(category, item):\\n # Verify user login. If not, redirect to login page.\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n else:\\n flash('Please log in.')\\n return redirect(url_for('home'))\\n # Query database with SQLAlchemy to display categories on page\\n categories = session.query(Categories).all()\\n if request.method == 'POST':\\n # Query database with SQLAlchemy and store queries as objects\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n item = (session.query(Items)\\n .filter_by(name=item.replace('-', ' '))\\n .one())\\n # Get form fields submitted by user, or retain item info\\n name = request.form['name'] if request.form['name'] else item.name\\n url = request.form['url'] if request.form['url'] else item.url\\n if request.form['photo_url']:\\n photo_url = request.form['photo_url']\\n else:\\n photo_url = item.photo_url\\n if request.form['description']:\\n description = request.form['description']\\n else:\\n description = item.description\\n category = request.form['item_category']\\n # Retrieve the database ID of the item's category\\n category_id = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n # Get user's database ID\\n user_db_id = (session.query(Users)\\n .filter_by(email=login_session['email'])\\n .one()).id\\n # Get database ID of creator\\n creator_db_id = item.creator_db_id\\n print(\\\"Current user's database primary key id is {}.\\\"\\n .format(user_db_id))\\n print(\\\"Item creator's database primary key id is {}.\\\"\\n .format(creator_db_id))\\n print('Item to edit is \\\"{}\\\".'.format(item.name))\\n # Only allow creator to edit. If not, redirect to login.\\n if user_db_id != creator_db_id:\\n flash('Only the creator can edit. Please log in as creator.')\\n return redirect(url_for('home'))\\n # Store edits in an object\\n edited_item = Items(name=name,\\n url=url,\\n photo_url=photo_url,\\n description=description,\\n category_id=category_id.id,\\n creator_db_id=user_db_id)\\n # Overwrite item object with new info from edited_item object\\n item.name = edited_item.name\\n item.url = edited_item.url\\n item.photo_url = edited_item.photo_url\\n item.description = edited_item.description\\n item.category_id = edited_item.category_id\\n session.add(item)\\n session.commit()\\n print('Item \\\"{}\\\" edited.'.format(edited_item.name))\\n # Return to homepage\\n return redirect(url_for('home'))\\n else:\\n # Query database with SQLAlchemy to display categories on page\\n categories = session.query(Categories).all()\\n # Render webpage\\n return render_template('edit_item.html',\\n categories=categories,\\n item=item,\\n login_status=login_status)\",\n \"def editItem(category_id, item_id):\\r\\n # authentication\\r\\n if 'username' not in login_session:\\r\\n flash('Please login to edit item')\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n # validation\\r\\n category = session.query(Category).filter_by(id=category_id).first()\\r\\n if not category:\\r\\n flash('Attempted operation on non-existent category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n editedItem = session.query(Item).filter_by(id=item_id,\\r\\n category_id=category_id).first()\\r\\n if not editedItem:\\r\\n flash('Attempt to edit non-existent item')\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n # authorization\\r\\n if login_session['user_id'] != editedItem.user_id:\\r\\n flash('Sorry, you are not authorized to edit the item \\\\'{}\\\\''\\r\\n .format(editedItem.name))\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n if request.method == 'POST':\\r\\n # update operation\\r\\n if request.form['name']:\\r\\n editedItem.name = request.form['name']\\r\\n\\r\\n if request.form['description']:\\r\\n editedItem.description = request.form['description']\\r\\n else:\\r\\n editedItem.description = ''\\r\\n session.add(editedItem)\\r\\n session.commit()\\r\\n flash('Edited Item \\\\'{}\\\\' Successfully'.format(editedItem.name))\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n else:\\r\\n # serve GET requests with the form\\r\\n return render_template(\\\"editItem.html\\\",\\r\\n category=category, item=editedItem)\",\n \"def edit_item(self, item_id, name, description, category_id, user_id):\\r\\n item = self._db_manager.get_item(item_id)\\r\\n if item is None:\\r\\n flash(\\\"Invalid item.\\\")\\r\\n return\\r\\n if item[\\\"user_id\\\"] != user_id:\\r\\n flash(\\\"Only the original creator can edit an item.\\\")\\r\\n return\\r\\n category = self._db_manager.get_category(category_id)\\r\\n if category is None:\\r\\n flash(\\\"Invalid category.\\\")\\r\\n return\\r\\n if category[\\\"user_id\\\"] != user_id:\\r\\n flash(\\\"You can only add items to categories you created.\\\")\\r\\n return\\r\\n flash(self._db_manager.edit_item(\\r\\n item_id=item_id,\\r\\n name=name,\\r\\n description=description,\\r\\n category_id=category_id\\r\\n ))\",\n \"def editCategory(category_id):\\n editedCategory = session.query(Category). \\\\\\n filter_by(id=category_id).one()\\n if editedCategory.user_id != login_session['user_id']:\\n flash('You are not authorized to edit this Category.\\\\\\n Please create your own Category in order to edit.')\\n return redirect(url_for('showallCategories'))\\n if request.method == 'POST':\\n if request.form['name']:\\n editedCategory.name = request.form['name']\\n if request.form['image']:\\n editedCategory.image = request.form['image']\\n session.add(editedCategory)\\n session.commit()\\n flash('Category Edit successfull')\\n return redirect(url_for('showallCategories'))\\n else:\\n return render_template(\\n 'editCategory.html', category_id=category_id,\\n category=editedCategory)\",\n \"def edit_category(category):\\n # Verify user login. If not, redirect to login page.\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n else:\\n flash('Please log in.')\\n return redirect(url_for('home'))\\n if request.method == 'POST':\\n # Query database with SQLAlchemy and store query as an object\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n # Get form fields\\n edit_category_name = request.form['edit_category_name']\\n # Get user's database ID\\n user_db_id = (session.query(Users)\\n .filter_by(email=login_session['email'])\\n .one()).id\\n # Get database ID of category creator\\n creator_db_id = category.creator_db_id\\n print(\\\"Current user's database primary key id is {}.\\\"\\n .format(user_db_id))\\n print(\\\"Category creator's database primary key id is {}.\\\"\\n .format(creator_db_id))\\n print('Category to edit is \\\"{}\\\".'.format(category.name))\\n # Only allow creator to edit. If not, redirect to login.\\n if user_db_id != creator_db_id:\\n flash('Only the creator can edit. Please log in as creator.')\\n return redirect(url_for('home'))\\n # Flash messages for incomplete item info\\n if not request.form['edit_category_name']:\\n flash('Please identify category.')\\n return redirect(url_for('edit_category'))\\n # Overwrite object with new info for database\\n category.name = edit_category_name\\n print('Category name for database is \\\"{}\\\".'.format(category.name))\\n session.add(category)\\n session.commit()\\n # Return to homepage\\n return redirect(url_for('home'))\\n else:\\n # Render webpage\\n return render_template('edit_category.html',\\n category_name=category,\\n login_status=login_status)\",\n \"def edit_item_details(item_id):\\n category_id = None\\n if 'category_id' in request.args:\\n category_id = int(request.args['category_id'])\\n if 'userid' not in login_session:\\n flash('Unfortunately you need to be logged in to make changes', 'error')\\n return redirect(url_for('show_homepage'))\\n\\n item = None\\n if item_id != 0:\\n item = is_user_the_creator(item_id)\\n if request.method == 'GET':\\n categories = session.query(Category).order_by(asc(Category.name)).all()\\n return display_item(categories, item, item_id, category_id)\\n else:\\n return save_item(item, item_id)\",\n \"def editCategory(category_id):\\n\\n if 'username' not in login_session:\\n return redirect('/login')\\n\\n editedCategory = session.query(Category).filter_by(id=category_id).one()\\n if editedCategory.user_id != login_session['user_id']:\\n flash('You are not the creator of %s category, and cannot modify it' %\\n editedCategory.name)\\n return redirect(url_for('showCategories'))\\n else:\\n if request.method == 'POST':\\n if \\\"btn_edit\\\" in request.form:\\n if request.form['name']:\\n editedCategory.name = request.form['name']\\n flash('Category Successfully Edited %s' %\\n editedCategory.name)\\n return redirect(url_for('showCategories'))\\n else:\\n return redirect(url_for('showCategories'))\\n else:\\n return redirect(url_for('showCategories'))\\n else:\\n return render_template('editCategory.html',\\n category=editedCategory,\\n user=getUserInfo(login_session['user_id']))\",\n \"def update_category_item(catalog_item_id):\\n edited_item = session.query(CatalogItem). \\\\\\n filter_by(id=catalog_item_id).one()\\n if request.form['name']:\\n edited_item.name = request.form['name']\\n if request.form['description']:\\n edited_item.description = request.form['description']\\n if request.form['price']:\\n edited_item.price = request.form['price']\\n session.add(edited_item)\\n session.commit()\",\n \"def edit_item(item_id):\\n if 'userinfo' not in session.keys():\\n session['target'] = url_for('edit_item', item_id=item_id)\\n return redirect(url_for('gconnect'))\\n if request.method == 'POST':\\n sqlsession = SQLSESSION()\\n item = sqlsession.query(Item).filter_by(id=item_id).first()\\n item.name = request.form['name']\\n item.category_id = request.form['category']\\n item.description = request.form['description']\\n sqlsession.commit()\\n return redirect(url_for('view_item', item_id=item_id))\\n sqlsession = SQLSESSION()\\n item = sqlsession.query(Item).filter_by(id=item_id).first()\\n categories = sqlsession.query(Category).all()\\n return render_template(\\\"edit_item.html\\\",\\n item=item,\\n categories=categories)\",\n \"def editCategory(category_id):\\n\\n edited_category = session.query(Category).filter_by(id=category_id).first()\\n if edited_category.user_id != login_session['user_id']:\\n flash(\\\"You are authorised to Edit category created by You only!\\\")\\n\\n return redirect(url_for(\\\"showCatalog\\\"))\\n\\n if request.method == 'POST':\\n if request.form['name'] != '':\\n edited_category.name = request.form['name']\\n session.add(edited_category)\\n session.commit()\\n flash('Category Successfully Edited %s' % edited_category.\\n name)\\n return redirect(url_for('showCatalog'))\\n else:\\n flash(\\\"Error editing category!\\\")\\n return render_template('editCategory.html',\\n category=edited_category)\\n else:\\n return render_template('editcategory.html',\\n category=edited_category)\",\n \"def editCategory(category_id):\\r\\n # authentication\\r\\n if 'username' not in login_session:\\r\\n flash('Please login to edit category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n # validation\\r\\n editedCategory = session.query(Category).filter_by(id=category_id).first()\\r\\n if not editedCategory:\\r\\n flash('Attempt to edit non-existent category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n # authorization\\r\\n if login_session['user_id'] != editedCategory.user_id:\\r\\n flash('Sorry, you are not authorized to edit the category \\\\'{}\\\\''\\r\\n .format(editedCategory.name))\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n if request.method == 'POST':\\r\\n # update operation\\r\\n if request.form['name']:\\r\\n editedCategory.name = request.form['name']\\r\\n\\r\\n if request.form['description']:\\r\\n editedCategory.description = request.form['description']\\r\\n else:\\r\\n editedCategory.description = ''\\r\\n session.add(editedCategory)\\r\\n session.commit()\\r\\n flash('Edited Category \\\\'{}\\\\' Successfully'.format(\\r\\n editedCategory.name))\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n else:\\r\\n # serve GET requests with form\\r\\n return render_template(\\\"editCategory.html\\\", category=editedCategory)\",\n \"def edit_category(self, category_id, name, user_id):\\r\\n category = self._db_manager.get_category(category_id)\\r\\n if category is None:\\r\\n flash(\\\"Invalid category.\\\")\\r\\n return\\r\\n if category[\\\"user_id\\\"] != user_id:\\r\\n flash(\\\"Only the original creator can edit a category.\\\")\\r\\n return\\r\\n flash(self._db_manager.edit_category(category_id, name))\",\n \"def edit_category(category_id):\\n\\n category = Category.query.filter(\\n Category.id == category_id,\\n Category.user_id == current_user.id\\n ).first()\\n\\n if not category:\\n flash(\\\"Couldn't find that category\\\", category='warning')\\n return redirect(request.referrer)\\n\\n form = CategoryForm()\\n form.name.current_user_id = current_user.id\\n\\n if form.validate_on_submit():\\n category.name = form.name.data.capitalize()\\n db.session.commit()\\n flash('Successfully updated category', 'success')\\n return redirect(url_for('url.index'))\\n\\n elif request.method == 'GET':\\n form.name.data = category.name\\n\\n return render_template(\\n 'forms/form.html',\\n form_title='Edit Category',\\n form=form,\\n form_name='category',\\n action=url_for('url.edit_category', category_id=category_id))\",\n \"def newItem(category_id):\\n editedCategory = session.query(Category). \\\\\\n filter_by(id=category_id).one()\\n if editedCategory.user_id != login_session['user_id']:\\n flash('You are not authorized to edit this Category.\\\\\\n Please create your own Category in order to edit.')\\n return redirect(url_for('showCategory', category_id=category_id))\\n if request.method == 'POST':\\n newItem = Item(\\n name=request.form['name'],\\n description=request.form['description'],\\n price=request.form['price'],\\n category_id=category_id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Item created')\\n return redirect(url_for('showCategory',\\n category_id=category_id))\\n else:\\n return render_template('newItem.html', category_id=category_id)\",\n \"def edit_category(category_name):\\n\\n category = Category.query.filter_by(name=category_name).first_or_404()\\n\\n if category.owner != current_user:\\n flash(\\\"Failed to edit category %s since you are not the owner.\\\" %\\n category.name)\\n return redirect(url_for('.index'))\\n\\n form = AddOrEditCategoryForm()\\n if form.validate_on_submit():\\n category.name = form.name.data\\n try:\\n db.session.commit()\\n except:\\n flash(\\n (\\\"Failed to edit category \\\\\\\"%s\\\\\\\".\\\"\\n \\\" Make sure that the category name is unique.\\\")\\n % category.name)\\n else:\\n flash(\\\"Category \\\\\\\"%s\\\\\\\" has been edited.\\\" % category.name)\\n finally:\\n return redirect(url_for('.index'))\\n form.name.data = category.name\\n return render_template('add_or_edit.html', form=form)\",\n \"def editItem(category_id, item_id):\\r\\n if 'username' not in login_session:\\r\\n return redirect(url_for('showLogin'))\\r\\n session = DBSession()\\r\\n editedItem = session.query(Item).filter_by(id=item_id).one()\\r\\n if editedItem.user_id != login_session['user_id']:\\r\\n return \\\"<script>function myFunction() {alert('You are not authorized to edit this item.');}</script><body onload='myFunction()''>\\\"\\r\\n if request.method == 'POST':\\r\\n editedItem.name = request.form['name']\\r\\n session.add(editedItem)\\r\\n session.commit()\\r\\n return redirect(url_for('showCategoryItems', category_id=category_id))\\r\\n else:\\r\\n return render_template('edititem.html', category_id=category_id, item=editedItem)\",\n \"def edit_item(item_id):\\n\\n item = Item.query.filter(\\n Item.id == item_id,\\n Item.user_id == current_user.id\\n ).first()\\n\\n if not item:\\n flash(\\\"Couldn't find a item with that id\\\", category='warning')\\n return redirect(request.referrer)\\n\\n form = ItemForm()\\n form.editting_item_id = item_id\\n # Query for select field\\n form.category_id.query = Category.query.filter(\\n Category.user_id == current_user.id).all()\\n\\n if form.validate_on_submit():\\n item.category_id = form.category_id.data.id\\n item.name = form.name.data.capitalize()\\n item.description = form.description.data\\n db.session.commit()\\n flash('Successfully updated Item', 'success')\\n return redirect(url_for('url.index'))\\n\\n elif request.method == 'GET':\\n form.name.data = item.name\\n form.description.data = item.description\\n\\n return render_template(\\n 'forms/form.html',\\n form_title='Edit Item',\\n form=form,\\n form_name='item',\\n action=url_for('url.edit_item', item_id=item_id))\",\n \"def edit_item(item_name):\\n\\n item = Item.query.filter_by(name=item_name).first_or_404()\\n\\n if item.owner != current_user:\\n flash(\\\"Failed to edit item %s since you are not the owner.\\\" %\\n item.name)\\n return redirect(url_for('.index'))\\n\\n form = AddOrEditItemForm(Category.query.order_by(Category.name).all())\\n if form.validate_on_submit():\\n\\n img_upload_name = secure_filename(form.img_upload.data.filename)\\n img_deletehash = None\\n img_url = None\\n\\n # Delete uploaded image on Imgur\\n if item.img_deletehash is not None \\\\\\n and not delete_image(item.img_deletehash):\\n flash(\\\"Failed to edit item \\\\\\\"%s\\\\\\\".\\\" % item.name)\\n return redirect(url_for('.index'))\\n\\n # Upload new image on Imgur\\n if img_upload_name != '':\\n img_url, img_deletehash = upload_image(form.img_upload.data)\\n print \\\"img_url: \\\" + img_url\\n print \\\"img_deletehash: \\\" + img_deletehash\\n if img_url is None or img_deletehash is None:\\n flash(\\\"Failed to upload image.\\\")\\n return redirect(url_for('.index'))\\n\\n elif form.img_url.data != '':\\n img_url = form.img_url.data\\n\\n item.name = form.name.data\\n item.description = form.description.data\\n item.category = Category.query.get(form.category.data)\\n item.img_url = img_url\\n item.img_deletehash = img_deletehash\\n\\n try:\\n db.session.commit()\\n except:\\n flash(\\n (\\\"Failed to edit item \\\\\\\"%s\\\\\\\".\\\"\\n \\\" Make sure that the item name is unique.\\\") % item.name)\\n else:\\n flash(\\\"Item \\\\\\\"%s\\\\\\\" has been edited.\\\" % item.name)\\n finally:\\n return redirect(url_for('.index'))\\n\\n form.name.data = item.name\\n form.description.data = item.description\\n form.category.data = item.category.id\\n form.img_url.data = item.img_url\\n\\n return render_template('add_or_edit.html', form=form)\",\n \"def edit_recipe_category(title):\\n session['recipe_category_title'] = title\\n if request.method == 'POST':\\n result = USERS[session['username']].edit_recipe_category(session['recipe_category_title'],\\n request.form['title'])\\n if result == 'recipe_category edited':\\n flash(result, 'info')\\n else:\\n flash(result, 'warning')\\n return redirect(url_for('dashboard'))\\n return render_template('edit_recipe_category.html')\",\n \"def add_item():\\n\\n form = AddOrEditItemForm(Category.query.order_by(Category.name).all())\\n img_upload_name = None\\n if form.validate_on_submit():\\n img_upload_name = secure_filename(form.img_upload.data.filename)\\n img_deletehash = None\\n img_url = None\\n\\n # Upload image to Imgur if FileField is specified\\n if img_upload_name != '':\\n img_url, img_deletehash = upload_image(form.img_upload.data)\\n if img_url is None or img_deletehash is None:\\n flash(\\\"Failed to upload image.\\\")\\n return redirect(url_for('.index'))\\n elif form.img_url.data != '':\\n img_url = form.img_url.data\\n\\n new_item = Item(name=form.name.data, description=form.description.data,\\n category=Category.query.get(form.category.data),\\n img_url=img_url, img_deletehash=img_deletehash,\\n owner=current_user._get_current_object())\\n\\n try:\\n db.session.add(new_item)\\n db.session.commit()\\n except:\\n flash(\\n (\\\"Failed to add item \\\\\\\"%s\\\\\\\".\\\"\\n \\\" Make sure that the item name is unique.\\\") % new_item.name)\\n else:\\n flash(\\\"A new item \\\\\\\"%s\\\\\\\" has been added.\\\" % new_item.name)\\n finally:\\n return redirect(url_for('.index'))\\n\\n # Set SelectField's default value\\n category_name = request.args.get('category_name')\\n if category_name is not None:\\n default_category = Category.query.filter_by(name=category_name).first()\\n if default_category is None:\\n flash(\\\"Wrong parameter(s).\\\")\\n return redirect(url_for('.index'))\\n form.category.data = default_category.id\\n\\n return render_template('add_or_edit.html',\\n form=form, filename=img_upload_name)\",\n \"def editCategory(category_id):\\r\\n if 'username' not in login_session:\\r\\n return redirect(url_for('showLogin'))\\r\\n session = DBSession()\\r\\n editedCategory = session.query(Category).filter_by(id=category_id).one()\\r\\n if editedCategory.user_id != login_session['user_id']:\\r\\n return \\\"<script>function myFunction() {alert('You are not authorized to edit this category.');}</script><body onload='myFunction()''>\\\"\\r\\n if request.method == 'POST':\\r\\n editedCategory.name = request.form['name']\\r\\n session.add(editedCategory)\\r\\n session.commit()\\r\\n return redirect(url_for('showCategories'))\\r\\n else:\\r\\n return render_template('editcategory.html', category=editedCategory)\",\n \"def test_edit_category(self):\\n response = self.client.put('/api/v1/category/1',\\n data=json.dumps(category[3]),\\n content_type='application/json',\\n headers=self.admin_headers)\\n self.assertEqual(response.status_code, 201)\\n self.assertIn('Apparels', str(response.data))\",\n \"def update(self, request, *args, **kwargs):\\n response = super(CategoryViewSet).update(self, request, *args, *kwargs)\\n response.data['message'] = \\\"Categoria ha sido editada\\\"\",\n \"def update_item(item_id):\\n edited_item = session.query(Item).filter_by(id=item_id).one()\\n\\n # redirect to details page if current user does not own item\\n if edited_item.user_id != login_session['user_id']:\\n return redirect(\\n url_for(\\n 'item_details',\\n category_id=edited_item.category_id,\\n item_id=edited_item.id))\\n\\n if request.method == 'POST':\\n if request.form['category']:\\n edited_item.category_id = request.form['category']\\n if request.form['name']:\\n edited_item.name = request.form['name']\\n if request.form['description']:\\n edited_item.description = request.form['description']\\n edited_item.updated_date = datetime.datetime.now()\\n session.add(edited_item)\\n session.commit()\\n return redirect(\\n url_for(\\n 'item_details',\\n category_id=edited_item.category_id,\\n item_id=edited_item.id))\\n else:\\n categories = session.query(Category).all()\\n return render_template(\\n 'views/edit.html',\\n edited_item=edited_item,\\n categories=categories)\",\n \"def editItem(sport_id, item_id):\\n\\n sport = session.query(Sport).filter_by(id=sport_id).one()\\n editedItem = session.query(Item).filter_by(id=item_id).one()\\n if request.method == 'POST':\\n if request.form['name']:\\n editedItem.name = request.form['name']\\n if request.form['description']:\\n editedItem.description = request.form['description']\\n editedItem.user_id = login_session['user_id']\\n session.add(editedItem)\\n session.commit()\\n return redirect(url_for('showCatalog', sport_id=sport_id))\\n else:\\n return render_template('edititem.html', sport_id=sport_id,\\n item_id=item_id, sport=sport, item=editedItem)\",\n \"def edit_category(category_id):\\n if request.args.get('state') != login_session['state']:\\n response = make_response(\\n json.dumps({'error': 'Invalid state parameter.'}), 401\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n if 'username' not in login_session:\\n response = make_response(\\n json.dumps({'error': 'User is logged out. This should not happen'}), 401\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n try:\\n if request.method == 'POST':\\n category = session.query(Category).filter_by(id=category_id).all()\\n if len(category) > 0:\\n state = get_new_state()\\n login_session['state'] = state\\n category = category[0]\\n category.name = request.form['name']\\n session.add(category)\\n session.commit()\\n response = make_response(\\n json.dumps({'success': '', 'nonce': login_session['state']}), 200\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n else:\\n return make_response(jsonify(error=[\\\"No results found\\\"]), 404)\\n except Exception as inst:\\n print(type(inst))\\n print(inst.args)\\n print(inst)\",\n \"def render_edit_item_page(\\r\\n self, client_id, state, user_id, user_name, item_id):\\r\\n categories = self._db_manager.get_category_list(user_id)\\r\\n if len(categories) == 0:\\r\\n flash(\\\"You have created no categories to add items to.\\\")\\r\\n return\\r\\n item = self._db_manager.get_item(item_id)\\r\\n if item is None:\\r\\n flash(\\\"Invalid item.\\\")\\r\\n return\\r\\n if item[\\\"user_id\\\"] != user_id:\\r\\n flash(\\\"Only the original creator can edit an item.\\\")\\r\\n return\\r\\n return render_template(\\r\\n \\\"item_edit.html\\\",\\r\\n client_id=client_id,\\r\\n state=state,\\r\\n is_logged_in=True,\\r\\n user_name=user_name,\\r\\n categories=categories,\\r\\n item=item\\r\\n )\",\n \"def render_edit_category_page(\\r\\n self, client_id, state, user_id, user_name, category_id):\\r\\n category = self._db_manager.get_category(category_id)\\r\\n if category is None:\\r\\n flash(\\\"Invalid category.\\\")\\r\\n return\\r\\n if category[\\\"user_id\\\"] != user_id:\\r\\n # the check whether the user owns the category can only be made\\r\\n # here since the database needs to be consulted\\r\\n flash(\\\"Only the original creator can edit a category.\\\")\\r\\n return\\r\\n return render_template(\\r\\n \\\"category_edit.html\\\",\\r\\n client_id=client_id,\\r\\n state=state,\\r\\n is_logged_in=True,\\r\\n user_name=user_name,\\r\\n category=category\\r\\n )\",\n \"def editConcept(self):\\n if self.concept_list.currentIndex().isValid():\\n concept = self.concept_list.selectedItems()[0].data(Qt.UserRole)[0]\\n subcategory = self.concept_list.selectedItems()[0].data(Qt.UserRole)[1]\\n dlg = EditConceptDialog(self, concept, subcategory)\\n if dlg.exec_():\\n concept, subcategory = dlg.getValue()\\n self.db.update_concept(concept)\\n self.db.update_subcategory(subcategory)\\n self.search()\",\n \"def update_item_page(item_name, catagory_name):\\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\\n catagories = [c.name for c in Catagory.fetch_all()]\\n return render_template(\\n 'edit_item.html',\\n catagories=catagories,\\n values={\\n 'name': item.name,\\n 'catagory': item.catagory_name,\\n 'description': item.description\\n },\\n )\",\n \"def edit(self, **kwargs):\\n ...\",\n \"def adminedit(object, id):\\n\\n db = get_db()\\n\\n if request.method == \\\"POST\\\":\\n execute_string = 'UPDATE ' + object.title() + \\\" SET \\\"\\n\\n if object == 'post':\\n execute_string += 'title = \\\"' + request.form['title'] + '\\\", content = \\\"' + request.form['content'] + '\\\", authorId = ' + request.form[\\\"authorid\\\"] + ', categoryId = ' + request.form[\\\"categoryid\\\"] + ''\\n elif object == 'author':\\n execute_string += 'name = \\\"' + request.form['name'] + '\\\"'\\n elif object == 'category':\\n execute_string += 'name = \\\"' + request.form['name'] + '\\\", description = \\\"' + request.form['description'] + '\\\"'\\n\\n execute_string += \\\" WHERE id = \\\" + str(id)\\n db.execute(execute_string)\\n db.commit()\\n return redirect(url_for(\\\"adminview\\\", object=object))\\n\\n execute_string = \\\"SELECT * FROM \\\" + object.title() + \\\" WHERE id = \\\" + str(id)\\n item = db.execute(execute_string).fetchone()\\n\\n return render_template(\\\"new.html\\\", object=object, item=item)\",\n \"def careerCatagory_edit(request):\\r\\n action = tool.get_param_by_request(request.GET, 'action', \\\"add\\\", str)\\r\\n page_index = tool.get_param_by_request(request.GET, 'page_index', 1, int)\\r\\n\\r\\n careerCatagory = None\\r\\n if action == \\\"edit\\\" or action == \\\"show\\\":\\r\\n _id = tool.get_param_by_request(request.GET, 'id', 0, int)\\r\\n careerCatagory = api_careerCatagory.get_career_catagory_by_id(_id)\\r\\n\\r\\n if careerCatagory.is_error():\\r\\n return render_to_response(\\\"404.html\\\", {}, context_instance=RequestContext(request))\\r\\n\\r\\n careerCatagory = careerCatagory.result()[0]\\r\\n\\r\\n c = {\\\"careerCatagory\\\": careerCatagory, \\\"action\\\": action, \\\"page_index\\\": page_index}\\r\\n\\r\\n return render_to_response(\\\"mz_course/careerCatagory_save.html\\\", c, context_instance=RequestContext(request))\",\n \"def edit(self,item=None):\\r\\n raise AbstractError\\r\\n return False\",\n \"def test_edit_category(self):\\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\\n self.login('Bo_theo5@example.com', 'Bo1995')\\n self.dashboard()\\n self.category('Breakfast')\\n self.dashboard()\\n rv = self.edit_category('JunkFood')\\n self.assertIn(b'Category successfully updated', rv.data)\",\n \"def test_edit_non_existing_item(self):\\n response = self.client.put('/api/v1/category/200',\\n data=json.dumps(category[3]),\\n content_type='application/json',\\n headers=self.admin_headers)\\n self.assertEqual(response.status_code, 404)\\n self.assertIn('category with id 200 does not exist',\\n str(response.data))\",\n \"def test_edit_category(self):\\n rv = self.client().post(\\n '/categories/',\\n data={'category_name': 'Sauces'})\\n self.assertEqual(rv.status_code, 201)\\n rv = self.client().put(\\n '/categories/1',\\n data={\\n \\\"name\\\": \\\"Soups and Sauces\\\"\\n })\\n #self.assertEqual(rv.status_code, 200)\\n results = self.client().get('/categories/1')\\n #self.assertIn('Soups and', str(results.data))\",\n \"def update_item(item_name, catagory_name):\\n try:\\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\\n except NoResultFound:\\n abort(404)\\n errors = form_errors(request.form)\\n new_item_name = request.form.get('name')\\n new_catagory_name = request.form.get('catagory')\\n new_description = request.form.get('description')\\n if errors:\\n values = {\\n 'name': new_item_name,\\n 'catagory': new_catagory_name,\\n 'description': new_description\\n }\\n catagories = [c.name for c in Catagory.fetch_all()]\\n return render_template(\\n 'add_item.html',\\n catagories=catagories,\\n values=values,\\n errors=errors\\n )\\n item.update(\\n name=new_item_name,\\n catagory_name=new_catagory_name,\\n description=new_description\\n )\\n return redirect(url_for(\\n 'read_item', item_name=new_item_name, catagory_name=new_catagory_name\\n ))\",\n \"def newItem(category_id):\\n category = session.query(Category).filter_by(id=category_id).one()\\n if request.method == 'POST':\\n newItem = Item(name=request.form['name'],\\n description=request.form['description'],\\n price=request.form['price'], category_id=category.id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Item %s Successfully Created' % (newItem.name))\\n return redirect(url_for('showItem', category_id=category.id))\\n else:\\n return render_template('newitem.html', category_id=category.id)\",\n \"def edit_item(request, item_id):\\n if request.user.is_superuser:\\n item = get_object_or_404(Product, pk=item_id)\\n if request.method == \\\"POST\\\":\\n form = ProductForm(request.POST, request.FILES, instance=item)\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'Item was successfully updated.')\\n return redirect(reverse('item_info', args=[item.id]))\\n else:\\n messages.error(request, 'There was an issue updating the '\\n 'item. Please make sure the form is valid.')\\n else:\\n form = ProductForm(instance=item)\\n else:\\n messages.error(request, 'Sorry, you do not have permission to access '\\n 'this page.')\\n return redirect(reverse('home'))\\n\\n template = 'shop/edit_item.html'\\n context = {\\n 'form': form,\\n 'item': item,\\n }\\n\\n return render(request, template, context)\",\n \"def update(self, request, pk=None):\\n current_user = User.objects.get(id=request.user.id)\\n if current_user.is_staff:\\n try:\\n category = Category.objects.get(pk=pk)\\n except Category.DoesNotExist:\\n return Response({\\\"reason\\\": \\\"Doesn't Exist\\\"}, status=status.HTTP_400_BAD_REQUEST)\\n category.label = request.data['label']\\n category.approved = False\\n try:\\n category.save()\\n return Response({}, status=status.HTTP_204_NO_CONTENT)\\n except ValidationError as ex:\\n return Response({\\\"reason\\\": ex.message}, status=status.HTTP_400_BAD_REQUEST)\\n else:\\n return Response({'message': \\\"*Sigh*, you're not changing a thing, non-admin\\\"},\\n status=status.HTTP_403_FORBIDDEN)\",\n \"def newListItem(category_id):\\n\\n if 'username' not in login_session:\\n return redirect('/login')\\n\\n category = session.query(Category).filter_by(id=category_id).one()\\n\\n if category.user_id != login_session['user_id']:\\n flash('You are not the creator of %s category, and cannot modify it' %\\n category.name)\\n return redirect(url_for('showItems', category_id=category.id))\\n if request.method == 'POST':\\n if \\\"btn_new\\\" in request.form:\\n newItem = ListItem(name=request.form['name'],\\n description=request.form['description'],\\n category_id=category_id,\\n user_id=login_session['user_id'])\\n session.add(newItem)\\n session.commit()\\n flash('New Catalog Item: %s Successfully Created' % (newItem.name))\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return render_template('newitem.html',\\n category_id=category_id,\\n user=getUserInfo(login_session['user_id']))\",\n \"def editDetail(id):\\n form = EditDetailForm(request.form)\\n if request.method == \\\"GET\\\":\\n return render_template(\\\"/pages/edit.html\\\", form=form)\\n else:\\n choose = True\\n section = form.category.data\\n return redirect(url_for(\\\"editDetailSection\\\", id=id ,section=section))\",\n \"def display_item(categories, item, item_id, initial_category_id):\\n if item:\\n # Item already exists - display on page\\n return render_template('item_edit.html', item_id=item_id, item_name=item.Item.name,\\n item_description=item.Item.description, item_category=item.Item.category,\\n item_category_id=item.Item.category_id, categories=categories,\\n login_session=login_session,\\n csrf_token=generate_csrf_token())\\n else:\\n print('initial_category_id', initial_category_id)\\n # Default fields for creating a new item\\n return render_template('item_edit.html', item_id=0, item_name=\\\"\\\",\\n item_description=\\\"\\\", item_category=\\\"\\\",\\n item_category_id=initial_category_id, categories=categories,\\n login_session=login_session, initial_category_id=initial_category_id,\\n csrf_token=generate_csrf_token())\",\n \"def deleteCategory(category_id):\\n editedCategory = session.query(Category).\\\\\\n filter_by(id=category_id).one()\\n editedItem = session.query(Item).\\\\\\n filter_by(category_id=editedCategory.id).all()\\n print editedItem\\n if editedCategory.user_id != login_session['user_id']:\\n flash('You are not authorized to delete this Item.\\\\\\n Please create own Category with items in order to \\\\\\n delete items.')\\n return redirect(url_for('showallCategories'))\\n else:\\n if editedItem:\\n flash('Category Deletion not possible. \\\\\\n Please delete the items in Category')\\n return redirect(url_for('showCategory',\\n category_id=category_id))\\n elif request.method == 'POST':\\n session.delete(editedCategory)\\n session.commit()\\n flash('Category Deletion successfull')\\n return redirect(url_for('showallCategories'))\\n else:\\n return render_template(\\n 'deleteCategory.html', category_id=category_id,\\n category=editedCategory)\",\n \"def edit_entry():\\n if not check_admin_logged() :\\n abort(403)\\n\\n title = request.form['title']\\n category = request.form['category']\\n buydate = request.form['buydate']\\n ssid = decrypt_book_record(request.form['ssid'])\\n\\n if not check_items_in_form(title, category, buydate):\\n return redirect(url_for('show_entries_admin'))\\n\\n edited_entry = Entries.query.filter_by(\\n id=ssid, title=title, category=category, \\\\\\n buydate=buydate).first()\\n\\n if edited_entry is not None :\\n edited_entry.introduction = request.form['introduction']\\n if db.session.is_modified(edited_entry) :\\n # commit only if something is modified\\n try :\\n db.session.commit()\\n except IntegrityError as e :\\n log_error('error when edit:')\\n log_error(e.message)\\n flash(u'数据库操作失败导致更新失败！请看后台日志')\\n flash(u'成功更新条目')\\n\\n return redirect(url_for('show_entries_admin'))\",\n \"def edit_category(self, category_id, category_name, parent_id):\\n # [todo] - all parameters except category_id optional, fill others with\\n # current values\\n\\n # [todo] - validate category_id\\n # [todo] - validate new values\\n\\n # open a cursor\\n cur = self.get_cursor()\\n\\n stmt = \\\"UPDATE categories \\\" + \\\\\\n \\\"SET parent_id='{0}', \\\".format(parent_id) + \\\\\\n \\\"category_name='{0}' \\\".format(category_name) + \\\\\\n \\\"WHERE category_id={0}\\\".format(category_id)\\n\\n cur.execute(stmt)\\n\\n # close the cursor\\n self.close_cursor()\",\n \"def edit_recipe(description):\\n session['description']=description\\n if request.method == 'POST':\\n des_result=(USERS[session['username']].recipe_category[session['current_recipe_category_title']].\\n update_description(session['description'], request.form['description']))\\n status_result=(USERS[session['username']].recipe_category[session['current_recipe_category_title']].\\n update_status(session['description'], request.form['status']))\\n if des_result == 'recipe updated' or status_result == 'recipe updated':\\n flash('recipe updated', 'info')\\n else:\\n flash(des_result, 'warning')\\n return redirect(url_for('edit_recipe', recipe_category_title=session['current_recipe_category_title']))\\n return render_template('edit_recipe.html', item=USERS[session['username']]\\n .recipe_category[session['current_recipe_category_title']].recipes[description],\\n recipes=USERS[session['username']].\\n recipe_category[session['current_recipe_category_title']].recipes)\",\n \"def edit(item_id):\\n session = current_app.config['db']\\n item = session.query(WineABV).filter_by(id=item_id).one()\\n if request.method == \\\"POST\\\":\\n new_name = request.form['itemname']\\n item.name = new_name\\n try:\\n session.commit()\\n except exc.IntegrityError:\\n session.rollback()\\n flash(\\\"Duplicate values!\\\", 'danger')\\n return render_template('edit_form.html', item=item)\\n\\n flash(\\\"Successfully Edited '%s'\\\" % (new_name,), 'success')\\n return redirect(url_for('.show'))\\n else:\\n return render_template(template_prefix+'edit_form.html', item=item)\",\n \"def edit(self):\\n\\n pass\",\n \"def edit_item(action, user):\\n def get_item(items, id):\\n for item in items:\\n if item.id == id:\\n return item \\n raise Item.DoesNotExist()\\n \\n l = List.objects.get(id=action.get('listId', None))\\n verify_permission(l, user)\\n \\n editable_attributes = ('position', 'description', 'crossed')\\n \\n try:\\n item = get_item(l.items, action['what']['id'])\\n except:\\n raise Item.DoesNotExist\\n \\n for key, value in action['what'].iteritems():\\n if key == 'id': continue\\n elif key in editable_attributes:\\n item.__setattr__(key, value)\\n l.save()\\n \\n return l\",\n \"def newItem():\\n if request.method == 'POST':\\n db.createItem(\\n title=request.form['title'],\\n description=request.form['description'],\\n category_id=request.form['category'],\\n user_id=login_session['user_id'])\\n flash(\\\"New catalog item created!\\\", 'success')\\n return redirect(url_for('showCatalog'))\\n return render_template('new_item.html', categories=db.getAllCategories())\",\n \"def edit(self, *args, **kw):\\n id_tipo_item = UrlParser.parse_id(request.url, \\\"tipositems\\\")\\n url_action = \\\"../\\\"\\n \\n pp = PoseePermiso('redefinir tipo item',\\n id_tipo_item=id_tipo_item)\\n if not pp.is_met(request.environ):\\n flash(pp.message % pp.nombre_permiso, 'warning')\\n redirect(url_action)\\n tmpl_context.widget = self.edit_form\\n value = self.edit_filler.get_value( \\\\\\n values={'id_atributos_por_tipo_item': int(args[0])})\\n value['_method'] = 'PUT'\\n page = \\\"Atributo {nombre}\\\".format(nombre=value[\\\"nombre\\\"])\\n return dict(value=value, \\n page=page, \\n atras=url_action)\",\n \"def update(self, request, pk=None):\\n if not request.auth.user.is_staff:\\n return Response(\\n {'message': 'You must be an admin to update categories.'},\\n status=status.HTTP_403_FORBIDDEN\\n )\\n\\n # Do mostly the same thing as POST, but instead of\\n # creating a new instance of Category, get the Category record\\n # from the database whose primary key is `pk`\\n category = Categories.objects.get(pk=pk)\\n category.label = request.data[\\\"label\\\"]\\n \\n\\n category.save()\\n\\n # 204 status code means everything worked but the\\n # server is not sending back any data in the response\\n return Response({}, status=status.HTTP_204_NO_CONTENT)\",\n \"def edit_item(item_name):\\n item = Item.query.filter_by(name=item_name).first()\\n\\n # If the URL contains a bad item name, send a 404\\n if not item:\\n abort(404)\\n\\n # If the current user is not authorized to edit the item because\\n # the item was created by a different user, send a 403\\n elif current_user != item.user:\\n abort(403)\\n\\n form = ItemForm()\\n\\n # If the form is validated, update the item with its data to the\\n # database\\n if form.validate_on_submit():\\n\\n # If the item name or sport has been modified, check that an\\n # item with the same name and sport does not already exist, or\\n # send a flash message and do not add the new item to the\\n # database\\n if form.name.data != item.name or form.sport.data != item.sport:\\n query = Item.query.filter_by(name=form.name.data,\\n sport=form.sport.data).first()\\n if query:\\n flash('This sport already has an item with that name.', 'bad')\\n return redirect(url_for('items.edit_item',\\n item_name=item_name))\\n\\n # If the item name or sport has not been modified, update all\\n # details to the database, send a flash message, and redirect\\n # to 'home'\\n else:\\n item.name = form.name.data\\n item.sport = form.sport.data\\n item.category = form.category.data\\n item.description = form.description.data\\n item.private = form.private.data\\n db.session.commit()\\n flash(f'\\\"{item.name}\\\" has been updated!', 'good')\\n return redirect(url_for('items.item', item_name=item_name))\\n\\n # If the form is being requested, not submitted, pre-fill the form\\n # with existing item data\\n elif request.method == 'GET':\\n form.name.data = item.name\\n form.sport.data = item.sport\\n form.category.data = item.category\\n form.description.data = item.description\\n form.private.data = item.private\\n\\n return render_template('edit_item.html', item=item, form=form)\",\n \"def item_update(request):\\n if request.method == 'POST':\\n item_to_update = get_object_or_404(StockItem, pk=request.POST['id'])\\n item_to_update.name = request.POST['name']\\n item_to_update.count = int(request.POST['count'])\\n item_to_update.date_of_expiration = request.POST['exp']\\n item_to_update.fk_category = Category.objects.get(name=request.POST['cat'])\\n item_to_update.fk_subcategory = SubCategory.objects.get(name=request.POST['subcat'])\\n item_to_update.notes = request.POST['notes']\\n item_to_update.save()\\n return HttpResponse(status=200)\",\n \"def new_item():\\n if request.method == 'POST':\\n new_item = Item(\\n category_id=int(request.form['category']),\\n name=request.form['name'],\\n description=request.form['description'],\\n created_date=datetime.datetime.now(),\\n user_id=login_session['user_id'])\\n session.add(new_item)\\n session.commit()\\n return redirect(\\n url_for(\\n 'item_details',\\n category_id=new_item.category_id,\\n item_id=new_item.id))\\n else:\\n categories = session.query(\\n Category).all()\\n return render_template(\\n 'views/add.html',\\n categories=categories)\",\n \"def edit_seo(request, category_id, template_name=\\\"manage/category/seo.html\\\"):\\n category = lfs_get_object_or_404(Category, pk=category_id)\\n\\n if request.method == \\\"POST\\\":\\n form = SEOForm(instance=category, data=request.POST)\\n if form.is_valid():\\n form.save()\\n message = _(u\\\"SEO data has been saved.\\\")\\n else:\\n message = _(u\\\"Please correct the indicated errors.\\\")\\n else:\\n form = SEOForm(instance=category)\\n\\n seo_html = render_to_string(template_name, RequestContext(request, {\\n \\\"category\\\": category,\\n \\\"form\\\": form,\\n }))\\n\\n if request.is_ajax():\\n return HttpResponse(simplejson.dumps({\\n \\\"seo\\\": seo_html,\\n \\\"message\\\": message,\\n }, cls=LazyEncoder))\\n else:\\n return seo_html\",\n \"def transaction_edit(request, transaction_id, model_class=Transaction, form_class=TransactionForm, template_name='budget/transactions/edit.html'):\\n transaction = get_object_or_404(model_class.active.all(), pk=transaction_id)\\n if request.POST:\\n form = form_class(request.POST, instance=transaction)\\n \\n if form.is_valid():\\n category = form.save()\\n return HttpResponseRedirect(reverse('budget_transaction_list'))\\n else:\\n form = form_class(instance=transaction)\\n return render_to_response(template_name, {\\n 'transaction': transaction,\\n 'form': form,\\n }, context_instance=RequestContext(request))\",\n \"def update_recipe_category(db_id):\\r\\n\\r\\n # validates request form\\r\\n form = request.form\\r\\n error_list = validate_form(form, 'recipe_category')\\r\\n\\r\\n if error_list == []:\\r\\n # validates image URL\\r\\n image_URL = validate_image(form['img_link'])\\r\\n\\r\\n # keeps the old category name in case of change\\r\\n previous_name = mongo.db.recipe_categories.find_one(\\r\\n {'_id': ObjectId(db_id)})['name']\\r\\n\\r\\n # updates recipe category\\r\\n mongo.db.recipe_categories.update(\\r\\n {'_id': ObjectId(db_id)}, {'$set': {\\r\\n 'name': request.form.get('name'),\\r\\n 'img_link': image_URL}\\r\\n }\\r\\n )\\r\\n\\r\\n # updates the category name to the new one in the correspondent recipes\\r\\n\\r\\n mongo.db.recipes.update_many({'category': previous_name}, {'$set': {\\r\\n 'category': request.form.get('name')}}\\r\\n )\\r\\n\\r\\n # redirects to the recipe category search\\r\\n return redirect(url_for('search', collection='recipe_categories'))\\r\\n\\r\\n else:\\r\\n # initializes page title and header\\r\\n page_title = 'Update recipe category'\\r\\n page_header = 'Update a recipe category:'\\r\\n\\r\\n # sends error list back to the form to correct mistakes\\r\\n return render_template(\\r\\n 'edit_form.html',\\r\\n recipe_category=mongo.db.recipe_categories.find_one(\\r\\n {'_id': ObjectId(db_id)}),\\r\\n errors=error_list,\\r\\n form=form,\\r\\n page_title=page_title,\\r\\n page_header=page_header\\r\\n )\",\n \"def add_category():\\n\\n form = AddOrEditCategoryForm()\\n if form.validate_on_submit():\\n new_category = Category(name=form.name.data, owner=current_user._get_current_object())\\n try:\\n db.session.add(new_category)\\n db.session.commit()\\n except:\\n flash(\\n (\\\"Failed to add category \\\\\\\"%s\\\\\\\".\\\"\\n \\\" Make sure that the category name is unique.\\\")\\n % new_category.name)\\n else:\\n flash(\\\"A new category \\\\\\\"%s\\\\\\\" has been added.\\\" % new_category.name)\\n finally:\\n return redirect(url_for('.index'))\\n return render_template('add_or_edit.html', form=form)\",\n \"def edit_recipe(recipe_id):\\n if request.method == \\\"POST\\\":\\n submit = {\\n \\\"category_name\\\": request.form.get(\\\"category_name\\\"),\\n \\\"recipe_name\\\": request.form.get(\\\"recipe_name\\\"),\\n \\\"recipe_description\\\": request.form.get(\\\"recipe_description\\\"),\\n \\\"recipe_ingredients\\\": request.form.get(\\\"recipe_ingredients\\\"),\\n \\\"recipe_makes_for\\\": request.form.get(\\\"recipe_makes_for\\\"),\\n \\\"due_time\\\": request.form.get(\\\"due_time\\\"),\\n \\\"recipe_image\\\": request.form.get(\\\"recipe_image\\\"),\\n \\\"created_by\\\": session[\\\"user\\\"]\\n }\\n mongo.db.recipes.update({\\\"_id\\\": ObjectId(recipe_id)}, submit)\\n flash(\\\"Recipe Successfully Updated\\\")\\n return redirect(url_for(\\\"recipes\\\"))\\n\\n recipe = mongo.db.recipes.find_one({\\\"_id\\\": ObjectId(recipe_id)})\\n categories = mongo.db.categories.find().sort(\\\"category_name\\\", 1)\\n return render_template(\\n \\\"edit_recipe.html\\\", recipe=recipe, categories=categories)\",\n \"def edit_item(request, product_id):\\n\\n if not request.user.is_superuser:\\n messages.error(request, 'Sorry, you are not permitted to do that.')\\n return redirect(reverse('home'))\\n\\n product = get_object_or_404(Product, pk=product_id)\\n if request.method == 'POST':\\n form = ProductForm(request.POST, request.FILES, instance=product)\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'You have successfully updated store item!')\\n return redirect(reverse('home'))\\n else:\\n messages.error(request, 'Failed to update item. Please check the form.')\\n else:\\n form = ProductForm(instance=product)\\n messages.info(request, f'You are editing {product.name}')\\n\\n template = 'products/edit_item.html'\\n context = {\\n 'form': form,\\n 'product': product,\\n }\\n\\n return render(request, template, context)\",\n \"def editProfile():\\n form = EditProfileForm(request.form)\\n if request.method == \\\"GET\\\":\\n return render_template(\\\"/pages/editprofile.html\\\", form=form)\\n else:\\n choose = True\\n section = form.category.data\\n return redirect(url_for(\\\"editProfileSection\\\", section=section))\",\n \"def createItem(category_id):\\r\\n if 'username' not in login_session:\\r\\n return redirect(url_for('showLogin'))\\r\\n if request.method == 'POST':\\r\\n session = DBSession()\\r\\n item = Item(name=request.form['name'],\\r\\n description=request.form['description'],\\r\\n category_id=category_id,\\r\\n user_id=login_session['user_id'])\\r\\n session.add(item)\\r\\n session.commit()\\r\\n return redirect(url_for('showCategoryItems', category_id=category_id))\\r\\n else:\\r\\n return render_template('newitem.html', category_id=category_id)\",\n \"def edit_item(item_id):\\n if 'username' not in login_session:\\n response = make_response(\\n json.dumps({'error': 'User is logged out. This should not happen'}), 401\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n try:\\n if request.method == 'POST':\\n item = session.query(Item).filter_by(id=item_id).one()\\n item.picture = request.form['picture']\\n item.name = request.form['name']\\n item.price = request.form['price']\\n item.description = request.form['description']\\n item.user_id = login_session['user_id']\\n session.add(item)\\n session.commit()\\n response = make_response(\\n json.dumps({'success': '', 'nonce': login_session['state']}), 200\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n except Exception as inst:\\n print(type(inst))\\n print(inst.args)\\n print(inst)\",\n \"def addItem(category_id):\\r\\n # authentication\\r\\n if 'username' not in login_session:\\r\\n flash('Please login to add item')\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n # validation\\r\\n category = session.query(Category).filter_by(id=category_id).first()\\r\\n if not category:\\r\\n flash('Attempted operation on non-existent category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n if request.method == 'POST':\\r\\n # create operation\\r\\n name = request.form['name']\\r\\n description = request.form['description']\\r\\n if not name:\\r\\n flash('Add ItemError: Name can\\\\'t be empty')\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n newItem = Item(name=name, description=description,\\r\\n category_id=category_id, user_id=category.user_id)\\r\\n session.add(newItem)\\r\\n session.commit()\\r\\n flash('Added Item \\\\'{}\\\\' Successfully!'.format(newItem.name))\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n else:\\r\\n # serve GET requests with the form\\r\\n return render_template(\\\"addItem.html\\\", category=category)\",\n \"def test_category_mixed_on_edit(self):\\n self.go200('minus_upload')\\n self.formfile('minus_upload', 'file', AUDIO_FILE)\\n self.fv('minus_upload', 'categories', 'onecat')\\n self.submit200()\\n minus = MinusRecord.objects.all()[0]\\n self.assert_equal(minus.categories.count(), 1)\\n self.go200('minus_edit', [self.superuser, minus.id])\\n self.fv('minus_upload', 'add_category', 'yuppie')\\n self.submit200()\\n self.assert_equal(minus.categories.count(), 2)\\n self.assert_equal(minus.categories.all()[0].name, 'onecat')\\n self.assert_equal(minus.categories.all()[1].name, 'yuppie')\",\n \"def test_edit(self):\\n\\n\\t\\titem_id = mock_item()[0]\\n\\n\\t\\titem_data = {'title': 'Item Two', 'author': 'Author Two',\\n\\t\\t\\t'location': 'Location Two'}\\n\\t\\tmodels.edit(item_id, item_data)\\n\\n\\t\\titem = models.item(item_id)\\n\\n\\t\\tself.assertEqual(item['title'], item_data['title'])\\n\\t\\tself.assertEqual(item['author'], item_data['author'])\\n\\t\\tself.assertEqual(item['location'], item_data['location'])\",\n \"def test_edit_recipe_category(self):\\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\\n self.login('Bo_theo5@example.com', 'Bo1995')\\n self.dashboard()\\n self.category('JunkFood')\\n self.dashboard()\\n self.recipe_dashboard()\\n self.create_recipe('cakes', 'blah, blah, blah....mix ingredient, heat')\\n rv = self.edit_recipe('edited cakes', 'edited blah blah blah spoon , heat')\\n self.assertIn(b'Recipe successfully updated', rv.data)\",\n \"def deleteItem(category_id, item_id):\\n editedItem = session.query(Item).filter_by(id=item_id).one()\\n if editedItem.user_id != login_session['user_id']:\\n flash('You are not authorized to delete this Item.\\\\\\n Please create own Category with items in order to \\\\\\n delete items.')\\n return redirect(url_for('showallCategories'))\\n if request.method == 'POST':\\n session.delete(editedItem)\\n session.commit()\\n flash('Item Deletion successfull')\\n return redirect(url_for('showCategory', category_id=category_id))\\n else:\\n return render_template(\\n 'deleteItem.html', category_id=category_id,\\n item_id=item_id, item=editedItem)\",\n \"def add_item():\\n\\n form = ItemForm()\\n # Query for select field\\n form.category_id.query = Category.query.filter(\\n Category.user_id == current_user.id).all()\\n\\n if form.validate_on_submit():\\n new_item = Item(\\n category_id=form.category_id.data.id,\\n name=form.name.data.capitalize(),\\n description=form.description.data,\\n user_id=current_user.id)\\n db.session.add(new_item)\\n db.session.commit()\\n flash(\\\"New item '{}' was successfully created\\\".format(\\n form.name.data.capitalize()), category='success')\\n return redirect(url_for('url.index'))\\n\\n return render_template(\\n 'forms/form.html',\\n form_title='Add Item',\\n form=form,\\n form_name='item',\\n action=url_for('url.add_item'))\",\n \"def newItem():\\n if request.method == 'POST':\\n if not checkLogin():\\n return requests(url_for('catelog'))\\n\\n if request.form['name'].strip() == '':\\n flash('item create failed: name is empty!')\\n return redirect(url_for('newItem'))\\n\\n category = session.query(\\n Category).filter_by(\\n name=request.form['category']).one()\\n\\n ifCategory = session.query(Category).filter_by(\\n name=request.form['category']).one()\\n ifItem = session.query(Item).filter_by(\\n category_id=ifCategory.id,\\n name=request.form['name']).all()\\n if (len(ifItem) > 0):\\n flash('item create failed: item(%s) \\\\\\n is already exist in category(%s)' % (\\n ifItem[0].name,\\n ifCategory.name))\\n return redirect(url_for('catelog'))\\n\\n newItem = Item(\\n name=request.form['name'],\\n description=request.form['description'],\\n category=category,\\n auth=getLoginUser(),\\n time=getIntTime())\\n session.add(newItem)\\n session.commit()\\n\\n flash('new item created: %s' % newItem.name)\\n\\n return redirect(url_for(\\n 'itemDetail',\\n category_name=category.name,\\n item_name=newItem.name))\\n else:\\n all_category = session.query(Category).all()\\n return render_template(\\n 'new-item.html',\\n all_category=all_category,\\n isLogin=checkLogin())\",\n \"def edit(slug):\\n entry = get_object_or_404(Entry, Entry.slug == slug)\\n if request.method == 'POST':\\n if request.form.get('title'):\\n entry.title = request.form.get('title')\\n if request.form.get('content'):\\n entry.content = request.form.get('content')\\n entry.published = request.form.get('published') or False\\n entry.save()\\n\\n flash('Entry saved successfully!', 'success')\\n if entry.published:\\n return redirect(url_for('detail', slug=entry.slug))\\n else:\\n return redirect(url_for('edit', slug=entry.slug))\\n return render_template('edit.html', entry=entry)\",\n \"def menu_item_edit(restaurant_id, menu_id):\\n # If the user isn't logged in, send to the login page\\n if helper.handle_login(login_session) is False:\\n return redirect('/login')\\n\\n restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()\\n menu_item = session.query(MenuItem).filter_by(id=menu_id).one()\\n if request.method == 'POST':\\n if len(request.form['price']) > 0:\\n if '$' in request.form['price']:\\n menu_item.price = request.form['price']\\n else:\\n menu_item.price = '$' + request.form['price']\\n if len(request.form['description']) > 0:\\n menu_item.description = request.form['description']\\n if 'course' in request.form:\\n menu_item.course = request.form['course']\\n if 'file' in request.files:\\n img_id = helper.create_new_image_if_not_exists(file=request.files['file'],\\n title=request.form['img_name'])\\n if img_id != -1:\\n menu_item.image_id = img_id\\n session.add(menu_item)\\n session.commit()\\n flash(\\\"Menu item {} edited!\\\".format(menu_item.name))\\n return redirect(url_for('restaurant_menu', restaurant_id=restaurant_id))\\n else:\\n user_info = helper.get_user_if_exists(login_session)\\n return render_template('editmenu.html',\\n restaurant=restaurant,\\n menu_item=menu_item,\\n user_info=user_info)\",\n \"def edit():\",\n \"def create_item():\\n name = request.form['name']\\n catagory = request.form['catagory']\\n description = request.form['description']\\n errors = form_errors(request.form)\\n if errors:\\n catagories = [c.name for c in Catagory.fetch_all()]\\n values = {\\n 'name': name, 'catagory': catagory, 'description': description\\n }\\n return render_template(\\n 'add_item.html',\\n catagories=catagories,\\n values=values,\\n errors=errors\\n )\\n Item.create(name, catagory_name=catagory, description=description)\\n return redirect(url_for(\\n 'read_item', catagory_name=catagory, item_name=name\\n ))\",\n \"def test_update_category(self):\\n pass\",\n \"def editPost(self, id, useRawHTML):\\n old_data = self._extractPost(id)\\n print\\n content, publish = self._fillPost(useRawHTML, old_data)\\n\\n # Upload to server\\n try :\\n self.server.metaWeblog.editPost(\\n id, self.username, self.password,\\n content, publish\\n )\\n if raw_input(\\\"Change category ?[y|N] \\\") == \\\"y\\\" :\\n self._setCategorie(id)\\n except xmlrpclib.Fault as fault:\\n display_XMLRPC_errors(\\\"edit entry\\\", fault)\",\n \"def edit_item(self, item_id, transaction_id, description, amount,\\n category_id):\\n # [todo] - all parameters except item_id optional, fill others with\\n # current values\\n\\n # [todo] - validate item_id\\n # [todo] - validate new values\\n\\n # open a cursor\\n cur = self.get_cursor()\\n\\n stmt = \\\"UPDATE transaction_items \\\" + \\\\\\n \\\"SET transaction_id='{0}', \\\".format(transaction_id) + \\\\\\n \\\"description='{0}', \\\".format(description) + \\\\\\n \\\"amount='{0}', \\\".format(amount) + \\\\\\n \\\"category_id='{0}' \\\".format(category_id) + \\\\\\n \\\"WHERE transaction_item_id={0}\\\".format(item_id)\\n\\n cur.execute(stmt)\\n\\n # close the cursor\\n self.close_cursor()\",\n \"def put(self):\\n request = transforms.loads(self.request.get('request'))\\n\\n if not self.assert_xsrf_token_or_fail(\\n request, 'add-new-category', {}):\\n return\\n\\n if not roles.Roles.is_super_admin():\\n transforms.send_json_response(\\n self, 401, 'Access denied.')\\n return\\n\\n payload = request.get('payload')\\n updated_dict = transforms.json_to_dict(\\n transforms.loads(payload), self.get_schema_dict())\\n\\n errors = []\\n self.apply_updates(updated_dict, errors)\\n if not errors:\\n transforms.send_json_response(self, 200, 'Saved.')\\n else:\\n transforms.send_json_response(self, 412, '\\\\n'.join(errors))\",\n \"def EditLabel(self, item):\\r\\n \\r\\n self.Edit(item)\",\n \"def clean_category(self):\\n category = self.cleaned_data.get('category', None)\\n # Used in the view\\n self.category = category\\n self.category_slug = slugify(category)\\n\\n categories = self.instance.categories\\n\\n # delete the old original category if present\\n if self.original_category not in categories:\\n # add\\n if category is None:\\n raise forms.ValidationError('Category cannot be None')\\n else:\\n # append new cat if not None\\n categories.append(category)\\n self.message = self.added_message.format(category=category)\\n else:\\n # edit\\n categories.remove(self.original_category)\\n # set the message\\n self.message = self.modified_message.format(original_category=self.original_category, category=category)\\n\\n # set the instance categories to our updated\\n # ensure uniquness by convert to set then back to list\\n # cant use set as set loses sort order which is important here\\n self.instance.categories = categories\\n\\n return category\",\n \"def edit_item(self) -> None:\\n item = self.get_selected_item(self.tree_cache)\\n if item is None:\\n return\\n\\n text, ok = QInputDialog.getText(self, \\\"Edit data\\\", \\\"Data:\\\", text=item.data().get_value())\\n if ok:\\n item.setText(text)\\n item.data().set_value(text)\",\n \"def edit_recipe(request, recipe, **_kwargs):\\n return edit_view(request, _(\\\"Recipe\\\"), RecipeForm, recipe)\",\n \"def edit_items(request):\\n token = getToken(request)\\n superUser = isSuperUser(token)\\n if superUser == True:\\n id = request.data['id']\\n try:\\n items = Items.objects.get(id=id)\\n except:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n serializer = ItemsSerializer(items, data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n else:\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n else:\\n return Response(status=status.HTTP_401_UNAUTHORIZED)\",\n \"def edit_item(self):\\n for item in self.selection():\\n origin_name = self.set(item)[\\\"1\\\"]\\n origin_url = self.set(item)[\\\"2\\\"]\\n popup = GetItemURLDialogue(self, \\\"Edit Item\\\", origin_name, origin_url)\\n\\n self.item(item, values=(popup.name, popup.url, self.set(item)[\\\"3\\\"]))\\n self.set(item)[\\\"2\\\"] = popup.url\\n\\n # Edit the item - backend\\n for row in s.item:\\n if row[\\\"item\\\"] == origin_name and row[\\\"url\\\"] == origin_url:\\n s.item.remove(row)\\n s.updateItem({\\\"item\\\": popup.name, \\\"url\\\": popup.url})\",\n \"def put(self):\\n request = transforms.loads(self.request.get('request'))\\n\\n if not self.assert_xsrf_token_or_fail(\\n request, 'update-category', {}):\\n return\\n\\n if not roles.Roles.is_super_admin():\\n transforms.send_json_response(\\n self, 401, 'Access denied.')\\n return\\n\\n payload = request.get('payload')\\n updated_dict = transforms.json_to_dict(\\n transforms.loads(payload), self.get_schema_dict())\\n\\n errors = []\\n self.apply_updates(updated_dict, errors)\\n if not errors:\\n transforms.send_json_response(self, 200, 'Saved.')\\n else:\\n transforms.send_json_response(self, 412, '\\\\n'.join(errors))\",\n \"def updateCategory(request, category_id):\\n try:\\n category = Category.objects.get(id=category_id)\\n print(\\\"id\\\", category)\\n except Category.DoesNotExist:\\n return Response({'message': \\\"requested category does not exist\\\"}, status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n serializer = CategorySerializer(category)\\n return Response({\\\"data\\\": serializer.data}, status=status.HTTP_200_OK)\\n\\n elif request.method == \\\"PUT\\\":\\n serializer = CategorySerializer(category, data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(\\n {'data': serializer.data, \\\"message\\\": \\\"Data updated successfullt\\\", \\\"status\\\": status.HTTP_200_OK})\\n else:\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def edit(self):\\n if not self.context.model.is_editable():\\n raise Unauthorized(\\\"Editing is not allowed\\\")\\n\\n title = self.request.get('title')\\n if not title:\\n return JSONResponse(self.request).error(\\n _('agenda_item_update_empty_string',\\n default=u\\\"Agenda Item title must not be empty.\\\")).proceed().dump()\\n\\n title = title.decode('utf-8')\\n if self.agenda_item.has_proposal:\\n if len(title) > ISubmittedProposal['title'].max_length:\\n return JSONResponse(self.request).error(\\n _('agenda_item_update_too_long_title',\\n default=u\\\"Agenda Item title is too long.\\\")\\n ).proceed().dump()\\n\\n self.agenda_item.set_title(title)\\n return JSONResponse(self.request).info(\\n _('agenda_item_updated',\\n default=u\\\"Agenda Item updated.\\\")).proceed().dump()\",\n \"def add_category():\\n # Verify user login. If not, redirect to login page.\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n else:\\n flash('Please log in.')\\n return redirect(url_for('home'))\\n if request.method == 'POST':\\n # Get form fields\\n new_category_name = request.form['new_category_name']\\n # Get user's database ID for the item's database entry\\n user_db_id = (session.query(Users)\\n .filter_by(email=login_session['email'])\\n .one()).id\\n print(\\\"Current user's database primary key id is {}.\\\"\\n .format(user_db_id))\\n # Flash messages for incomplete item info\\n if not request.form['new_category_name']:\\n flash('Please add category name.')\\n return redirect(url_for('add_category'))\\n # Query database for item name\\n category_name_in_db = (session.query(Categories.name)\\n .filter_by(name=new_category_name)\\n .all())\\n # If the category name is already in the database, don't add\\n if category_name_in_db:\\n print('Category name \\\"{}\\\" already in database.'\\n .format(new_category_name))\\n flash('Category name \\\"{}\\\" already in database.'\\n .format(new_category_name))\\n return redirect(url_for('add_category'))\\n # If user is logged in, and all info provided, add category\\n new_category = Categories(\\n name=new_category_name,\\n creator_db_id=user_db_id)\\n session.add(new_category)\\n session.commit()\\n print('Category {} successfully created.'.format(new_category_name))\\n # Return to homepage\\n return redirect(url_for('home'))\\n else:\\n # Render webpage\\n return render_template('add_category.html',\\n login_status=login_status)\",\n \"def edit_recipe(id):\\n existing_recipe = mongo.db.recipes.find_one({\\\"_id\\\": ObjectId(id)})\\n\\n if request.method == \\\"POST\\\":\\n recipe = recipe_parser(dict(request.form), session[\\\"user\\\"])\\n mongo.db.recipes.update({\\\"_id\\\": ObjectId(id)}, recipe)\\n return redirect(url_for(\\\"recipes\\\"))\\n\\n return render_template(\\\"recipes/edit.html\\\", recipe=existing_recipe)\",\n \"def view_and_edit_listing(request, listing_id):\\n categories = Category.objects.all()\\n listing = get_object_or_404(Listing, pk=listing_id)\\n\\n if request.method == 'POST':\\n editform = AddListingForm(\\n request.POST,\\n request.FILES,\\n instance=listing)\\n if editform.is_valid():\\n listing.save()\\n messages.success(\\n request,\\n 'Thank you. Your listing has been updated')\\n return redirect(reverse('addlisting'))\\n else:\\n editform = AddListingForm(instance=listing)\\n\\n context = {\\n 'editform': editform,\\n 'listing': listing,\\n 'categories': categories\\n }\\n return render(request, 'editlisting.html', context)\",\n \"def setResourceCategory(self, resource_category_id, extraParams={}):\\n import labstep.entities.resource.repository as resourceRepository\\n\\n return resourceRepository.editResource(\\n self, resource_category_id=resource_category_id, extraParams=extraParams\\n )\",\n \"def put(self):\\n request = transforms.loads(self.request.get('request'))\\n key = self.request.get('key')\\n\\n if not self.assert_xsrf_token_or_fail(\\n request, 'update-course-category', {'key': key}):\\n return\\n\\n if not roles.Roles.is_super_admin():\\n transforms.send_json_response(\\n self, 401, 'Access denied.', {'key': self.KEY})\\n return\\n\\n payload = request.get('payload')\\n updated_dict = transforms.json_to_dict(\\n transforms.loads(payload), self.get_schema_dict())\\n\\n errors = []\\n self.apply_updates(updated_dict, errors)\\n if not errors:\\n transforms.send_json_response(self, 200, 'Saved.')\\n else:\\n transforms.send_json_response(self, 412, '\\\\n'.join(errors))\",\n \"def restaurantMenuItemEdit(restaurant_id, menu_id):\\n try:\\n restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one()\\n menuItem = session.query(MenuItem).filter_by(id=menu_id).one()\\n if request.method == 'POST':\\n if request.form['name']:\\n menuItem.name = request.form['name']\\n if request.form['description']:\\n menuItem.description = request.form['description']\\n if request.form['price']:\\n menuItem.price = request.form['price']\\n if request.form['course']:\\n menuItem.course = request.form['course']\\n\\n session.add(menuItem)\\n session.commit()\\n\\n flash('Menu Item Successfully Edited', 'menu')\\n return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id))\\n else:\\n return render_template('menuItemEdit.html', menuItem=menuItem, restaurant=restaurant)\\n\\n except exc.NoResultFound:\\n return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id))\",\n \"def set_category(request):\\n try:\\n # Update existing category if category_id exists, else create new Category\\n if \\\"category_id\\\" not in request.POST or not request.POST[\\\"category_id\\\"]:\\n # Create new Category\\n category = Category.objects.create(title=request.form.cleaned_data[\\\"title\\\"])\\n\\n ActionLogger().log(request.user, \\\"created\\\", \\\"Knowledgebase Category %s\\\" % category)\\n return format_ajax_response(True, \\\"Knowledgebase category created successfully.\\\")\\n else:\\n # Update existing category\\n category = Category.objects.get(pk=request.POST[\\\"category_id\\\"])\\n category.title = request.form.cleaned_data[\\\"title\\\"]\\n category.save()\\n\\n ActionLogger().log(request.user, \\\"modified\\\", \\\"Knowledgebase Category %s\\\" % category)\\n return format_ajax_response(True, \\\"Knowledgebase category updated successfully.\\\")\\n except Exception as ex:\\n logger.error(\\\"Failed to set_category: %s\\\" % ex)\\n return format_ajax_response(False, \\\"There was an error setting the knowledgebase category.\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79928815","0.7969549","0.79305446","0.76757014","0.7604712","0.7579564","0.7493831","0.74769086","0.74194235","0.7385975","0.7354665","0.73481214","0.7337863","0.7281295","0.7241027","0.723668","0.71674097","0.7164873","0.7072671","0.70634896","0.70056456","0.6998456","0.6962231","0.6916112","0.6848112","0.6818257","0.68046737","0.67940277","0.6763425","0.6731742","0.66509664","0.6629715","0.66032493","0.65908056","0.65829563","0.65818447","0.6572752","0.65710604","0.656662","0.6530093","0.65212107","0.64999634","0.6477473","0.64338225","0.64246404","0.63777024","0.6377467","0.63710237","0.63690484","0.63629395","0.6358474","0.6336044","0.6327031","0.6324329","0.6323912","0.6310666","0.6283479","0.6279502","0.62764287","0.626842","0.62407935","0.62051195","0.6190143","0.6188435","0.6183482","0.6159132","0.61264366","0.6106877","0.6072166","0.6038974","0.6036372","0.6030714","0.6017896","0.5998751","0.5993119","0.5964077","0.5958114","0.5936357","0.59014565","0.5891621","0.5885158","0.5870832","0.5869162","0.5865057","0.5857284","0.58429337","0.5818885","0.58110905","0.58018917","0.5800891","0.58006907","0.5798913","0.5794483","0.57866925","0.57777953","0.5770161","0.57684433","0.5758074","0.5747451","0.57459986"],"string":"[\n \"0.79928815\",\n \"0.7969549\",\n \"0.79305446\",\n \"0.76757014\",\n \"0.7604712\",\n \"0.7579564\",\n \"0.7493831\",\n \"0.74769086\",\n \"0.74194235\",\n \"0.7385975\",\n \"0.7354665\",\n \"0.73481214\",\n \"0.7337863\",\n \"0.7281295\",\n \"0.7241027\",\n \"0.723668\",\n \"0.71674097\",\n \"0.7164873\",\n \"0.7072671\",\n \"0.70634896\",\n \"0.70056456\",\n \"0.6998456\",\n \"0.6962231\",\n \"0.6916112\",\n \"0.6848112\",\n \"0.6818257\",\n \"0.68046737\",\n \"0.67940277\",\n \"0.6763425\",\n \"0.6731742\",\n \"0.66509664\",\n \"0.6629715\",\n \"0.66032493\",\n \"0.65908056\",\n \"0.65829563\",\n \"0.65818447\",\n \"0.6572752\",\n \"0.65710604\",\n \"0.656662\",\n \"0.6530093\",\n \"0.65212107\",\n \"0.64999634\",\n \"0.6477473\",\n \"0.64338225\",\n \"0.64246404\",\n \"0.63777024\",\n \"0.6377467\",\n \"0.63710237\",\n \"0.63690484\",\n \"0.63629395\",\n \"0.6358474\",\n \"0.6336044\",\n \"0.6327031\",\n \"0.6324329\",\n \"0.6323912\",\n \"0.6310666\",\n \"0.6283479\",\n \"0.6279502\",\n \"0.62764287\",\n \"0.626842\",\n \"0.62407935\",\n \"0.62051195\",\n \"0.6190143\",\n \"0.6188435\",\n \"0.6183482\",\n \"0.6159132\",\n \"0.61264366\",\n \"0.6106877\",\n \"0.6072166\",\n \"0.6038974\",\n \"0.6036372\",\n \"0.6030714\",\n \"0.6017896\",\n \"0.5998751\",\n \"0.5993119\",\n \"0.5964077\",\n \"0.5958114\",\n \"0.5936357\",\n \"0.59014565\",\n \"0.5891621\",\n \"0.5885158\",\n \"0.5870832\",\n \"0.5869162\",\n \"0.5865057\",\n \"0.5857284\",\n \"0.58429337\",\n \"0.5818885\",\n \"0.58110905\",\n \"0.58018917\",\n \"0.5800891\",\n \"0.58006907\",\n \"0.5798913\",\n \"0.5794483\",\n \"0.57866925\",\n \"0.57777953\",\n \"0.5770161\",\n \"0.57684433\",\n \"0.5758074\",\n \"0.5747451\",\n \"0.57459986\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.82450867"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14890,"cells":{"query":{"kind":"string","value":"Allows user to delete an existing category item"},"document":{"kind":"string","value":"def deleteItem(category_item_id):\n itemToDelete = db.findItem(id=category_item_id)\n if itemToDelete.user_id != login_session['user_id']:\n return not_authorized()\n if request.method == 'POST':\n db.deleteItem(itemToDelete)\n flash('%s Successfully Deleted' % itemToDelete.title, 'success')\n return redirect(url_for('showCatalog'))\n return render_template('delete_item.html', item=itemToDelete)"},"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 category_delete(request):\n if request.POST:\n cat = get_object_or_404(Category, pk=request.POST.get('id'))\n cat.delete()\n return HttpResponse(status=200)","def deleteCategory():\n deletecategory = deleteCategoryForm()\n # Look for CSRF token in form, verify POST method, and validate form data.\n if deletecategory.validate_on_submit():\n deleteID = deletecategory.deleteID.data\n category = Category.query.filter_by(id=deleteID).one()\n # Check logged in user against the category creator.\n if session['user_id'] == category.user_id:\n items = Item.query.filter_by(category=category.id)\n # Delete items related to category as well as category itself.\n if items:\n for i in items:\n db.session.delete(i)\n db.session.delete(category)\n db.session.commit()\n return redirect(url_for('index'))\n else:\n return redirect(url_for('index'))\n else:\n return redirect(url_for('index'))","def deleteCategory(category_id):\n editedCategory = session.query(Category).\\\n filter_by(id=category_id).one()\n editedItem = session.query(Item).\\\n filter_by(category_id=editedCategory.id).all()\n print editedItem\n if editedCategory.user_id != login_session['user_id']:\n flash('You are not authorized to delete this Item.\\\n Please create own Category with items in order to \\\n delete items.')\n return redirect(url_for('showallCategories'))\n else:\n if editedItem:\n flash('Category Deletion not possible. \\\n Please delete the items in Category')\n return redirect(url_for('showCategory',\n category_id=category_id))\n elif request.method == 'POST':\n session.delete(editedCategory)\n session.commit()\n flash('Category Deletion successfull')\n return redirect(url_for('showallCategories'))\n else:\n return render_template(\n 'deleteCategory.html', category_id=category_id,\n category=editedCategory)","def deleteListItem(category_id, item_id):\n\n if 'username' not in login_session:\n return redirect('/login')\n\n category = session.query(Category).filter_by(id=category_id).one()\n itemToDelete = session.query(ListItem).filter_by(id=item_id).one()\n\n if category.user_id != login_session['user_id']:\n flash('You are not the creator of %s category, and cannot modify it' %\n category.name)\n return redirect(url_for('showItems', category_id=category.id))\n\n if request.method == 'POST':\n if \"btn_delete\" in request.form:\n session.delete(itemToDelete)\n session.commit()\n flash('Catalog Item Successfully Deleted')\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return redirect(url_for('showItems', category_id=category_id))\n else:\n return render_template('deleteitem.html',\n item=itemToDelete,\n user=getUserInfo(login_session['user_id']))","def deleteItem(category_id, item_id):\n category = session.query(Category).filter_by(id=category_id).first()\n item = session.query(Item).filter_by(id=item_id).first()\n if item.user_id != login_session['user_id']:\n flash(\"You are authorised to delete items created by you!\")\n return redirect(url_for(\"showCatalog\"))\n if request.method == \"POST\":\n session.delete(item)\n session.commit()\n flash('%s Item Successfully Deleted' % (item.name))\n return redirect(url_for('showItem', category_id=item.category_id))\n else:\n return render_template(\"deleteitem.html\", item=item,\n category=category)","def deleteItem(category_id, item_id):\n editedItem = session.query(Item).filter_by(id=item_id).one()\n if editedItem.user_id != login_session['user_id']:\n flash('You are not authorized to delete this Item.\\\n Please create own Category with items in order to \\\n delete items.')\n return redirect(url_for('showallCategories'))\n if request.method == 'POST':\n session.delete(editedItem)\n session.commit()\n flash('Item Deletion successfull')\n return redirect(url_for('showCategory', category_id=category_id))\n else:\n return render_template(\n 'deleteItem.html', category_id=category_id,\n item_id=item_id, item=editedItem)","def delete_item(category, item):\n # Verify user login. If not, redirect to login page.\n login_status = None\n if 'email' in login_session:\n login_status = True\n else:\n flash('Please log in.')\n return redirect(url_for('home'))\n if request.method == 'POST':\n # Query database with SQLAlchemy and store queries as objects\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n item = (session.query(Items)\n .filter_by(name=item\n .replace('-', ' '), category_id=category.id)\n .one())\n # Get user's database ID\n user_db_id = (session.query(Users)\n .filter_by(email=login_session['email'])\n .one()).id\n # Get database ID of creator\n creator_db_id = item.creator_db_id\n print(\"Current user's database primary key id is {}.\"\n .format(user_db_id))\n print(\"Item creator's database primary key id is {}.\"\n .format(creator_db_id))\n print('Item to delete is \"{}\".'.format(item.name))\n # Only allow creator to edit. If not, redirect to login.\n if user_db_id != creator_db_id:\n flash('Only the creator can edit. Please log in as creator.')\n return redirect(url_for('home'))\n session.delete(item)\n session.commit()\n # Return to homepage\n return redirect(url_for('home'))\n else:\n # Render webpage\n return render_template('delete_item.html',\n item=item,\n login_status=login_status)","def delete_item(item_name, catagory_name):\n try:\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\n except NoResultFound:\n abort(404)\n item.delete()\n return redirect(url_for('home'))","def delete_category_item(category_item_id):\n item = session.query(CatalogItem).filter_by(id=category_item_id).one()\n session.delete(item)\n session.commit()","def delete(self):\n key = self.request.get('key')\n\n if not self.assert_xsrf_token_or_fail(\n self.request, 'delete-category', {}):\n return\n\n if not roles.Roles.is_super_admin():\n transforms.send_json_response(\n self, 401, 'Access denied.')\n return\n\n errors = []\n course_category.CourseCategoryDAO.delete_category(key, errors)\n if not errors:\n transforms.send_json_response(self, 200, 'Deleted.')\n else:\n transforms.send_json_response(self, 412, '\\n'.join(errors))","def delete_category(self):\n index_list = self.categoriesView.selectedIndexes()\n if index_list and index_list[0].isValid():\n index = index_list[0]\n category = index.data(Qt.UserRole)\n\n deletion = self.orm.delete_category(category)\n if not deletion:\n show_warning(\"Can't delete category\")\n else:\n self.show_categories()\n if category.parent is None:\n self.show_available_parents()","def delete_category(category):\n # Verify user login. If not, redirect to login page.\n login_status = None\n if 'email' in login_session:\n login_status = True\n else:\n flash('Please log in.')\n return redirect(url_for('home'))\n if request.method == 'POST':\n # Query database with SQLAlchemy and store queries as objects\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n category_items = (session.query(Items)\n .filter_by(category_id=category.id)\n .order_by(Items.name)\n .all())\n # Get user's database ID\n user_db_id = (session.query(Users)\n .filter_by(email=login_session['email'])\n .one()).id\n # Get database ID of category creator\n creator_db_id = category.creator_db_id\n print(\"Current user's database primary key id is {}.\"\n .format(user_db_id))\n print(\"Category creator's database primary key id is {}.\"\n .format(creator_db_id))\n print('Category to delete is \"{}\".'.format(category.name))\n print('Items to delete:')\n for item in category_items:\n print(item.name)\n # Only allow creator to edit. If not, redirect to login.\n if user_db_id != creator_db_id:\n flash('Only the creator can edit. Please log in as creator.')\n return redirect(url_for('home'))\n session.delete(category)\n for item in category_items:\n session.delete(item)\n session.commit()\n # Return to homepage\n return redirect(url_for('home'))\n else:\n # Render webpage\n return render_template('delete_category.html',\n category_name=category,\n login_status=login_status)","def deleteItem(category_id, item_id):\r\n # authentication\r\n if 'username' not in login_session:\r\n flash('Please login to add item')\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n # validation\r\n category = session.query(Category).filter_by(id=category_id).first()\r\n if not category:\r\n flash('Attempted operation on non-existent category')\r\n return redirect(url_for('showCategories'))\r\n\r\n deletedItem = session.query(Item).\\\r\n filter_by(id=item_id, category_id=category_id).first()\r\n if not deletedItem:\r\n flash('Attempt to delete non-existent item')\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n # authorization\r\n if login_session['user_id'] != deletedItem.user_id:\r\n flash('Sorry, you are not authorized to delete the item \\'{}\\''\r\n .format(deletedItem.name))\r\n return redirect(url_for('showItems', category_id=category_id))\r\n\r\n if request.method == 'POST':\r\n # delete operation\r\n session.delete(deletedItem)\r\n session.commit()\r\n flash('Deleted Item \\'{}\\' Successfully'.format(deletedItem.name))\r\n return redirect(url_for('showItems', category_id=category_id))\r\n else:\r\n # serve GET requests with confirmation form\r\n return render_template(\"deleteItem.html\",\r\n category=deletedItem.category, item=deletedItem)","def delete_category(request, id):\n\n if request.method == \"POST\":\n Category.objects.get(id=id).delete()\n messages.success(request, \"Category deleted successfully.\")\n return redirect(\"category\")\n\n return render(request, \"core/delete_category.html\", {\n \"object\": Category.objects.get(id=id)\n })","def delete_item(category, name):\r\n item_key = course_key.make_usage_key(category, name)\r\n resp = self.client.delete(get_url('xblock_handler', item_key))\r\n self.assertEqual(resp.status_code, 204)\r\n _test_no_locations(self, resp, status_code=204, html=False)","def delete_category(category_id):\n mongo.db.categories.remove({\"_id\": ObjectId(category_id)})\n flash(\"Recipe was deleted\")\n return redirect(url_for(\"get_categories\"))","def delete_category(key):\n try:\n category = Categories.objects.get(pk=key)\n except ObjectDoesNotExist:\n return Response({'status': CATEGORY_NOT_FOUND}, status=status.HTTP_404_NOT_FOUND)\n\n setattr(category, 'is_delete', True)\n category.save()\n return Response({'status': CATEGORY_DELETED}, status=status.HTTP_200_OK)","def delete(id):\r\n\r\n category = Category.query.get_or_404(id)\r\n db.session.delete(category)\r\n db.session.commit()\r\n flash('You have successfully deleted the category.')\r\n\r\n # redirect to the category page\r\n return redirect(url_for('category.list'))","def delete_category(request):\n try:\n categories = request.POST.getlist('category_id', 0)\n category = Category.objects.filter(pk__in=categories).delete()\n ActionLogger().log(request.user, \"deleted\", \"Knowledgebase Category %s\" % categories)\n return format_ajax_response(True, \"Knowledgebase category(s) deleted successfully.\")\n except Exception as ex:\n logger.error(\"Failed to delete_category: %s\" % ex)\n return format_ajax_response(False, \"There was an error deleting knowledgebase category(s).\")","def deleteCategory(category_id):\r\n if 'username' not in login_session:\r\n return redirect(url_for('showLogin'))\r\n session = DBSession()\r\n deletedCategory = session.query(Category).filter_by(id=category_id).one()\r\n if deletedCategory.user_id != login_session['user_id']:\r\n return \"<script>function myFunction() {alert('You are not authorized to delete this category.');}</script><body onload='myFunction()''>\"\r\n if request.method == 'POST':\r\n session.delete(deletedCategory)\r\n deletedItems = session.query(Item).filter_by(\r\n category_id=category_id).all()\r\n for i in deletedItems:\r\n session.delete(i)\r\n session.commit()\r\n return redirect(url_for('showCategories'))\r\n else:\r\n return render_template('deletecategory.html', category=deletedCategory)","def delete_item(item_id):\n if 'userinfo' not in session.keys():\n session['target'] = url_for('delete_item', item_id=item_id)\n return redirect(url_for('gconnect'))\n if request.method == 'POST':\n sqlsession = SQLSESSION()\n item = sqlsession.query(Item).filter_by(id=item_id).first()\n sqlsession.delete(item)\n sqlsession.commit()\n return redirect(\"/\")\n sqlsession = SQLSESSION()\n item = sqlsession.query(Item, Category).join(Category)\\\n .filter(Item.id == item_id).first()\n return render_template(\"delete_item.html\", item=item)","def delete_recipe_category(title):\n result = USERS[session['username']].delete_recipe_category(title)\n if result == \"recipe category deleted\":\n flash(result, 'info')\n else:\n flash(result, 'warning')\n return redirect(url_for('categories'))","def delete_item_page(item_name, catagory_name):\n return render_template(\n 'delete_item.html', item_name=item_name, catagory_name=catagory_name\n )","def test_delete_a_category(self):\n self.test_add_category_success()\n response = self.client.delete('/categories/1',\n headers={\"Authorization\": self.token})\n self.assertEqual(response.status_code, 200)\n self.assertIn('category deleted permanently',\n response.data.decode())","def delete(self, item):\n self._createAction(item, \"delete\")","def deleteItem(category_id, item_id):\r\n if 'username' not in login_session:\r\n return redirect(url_for('showLogin'))\r\n session = DBSession()\r\n deletedItem = session.query(Item).filter_by(id=item_id).one()\r\n if deletedItem.user_id != login_session['user_id']:\r\n return \"<script>function myFunction() {alert('You are not authorized to delete this item.');}</script><body onload='myFunction()''>\"\r\n if request.method == 'POST':\r\n session.delete(deletedItem)\r\n session.commit()\r\n return redirect(url_for('showCategoryItems', category_id=category_id))\r\n else:\r\n return render_template('deleteitem.html', item=deletedItem)","def test_delete_category(self):\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\n self.login('Bo_theo5@example.com', 'Bo1995')\n self.dashboard()\n self.category('JunkFood')\n self.dashboard()\n rv = self.del_category()\n self.assertIn(b'successfully deleted category', rv.data)","def test_delete_category(self):\n pass","def delete_category(category_name):\n\n category = Category.query.filter_by(name=category_name).first_or_404()\n if category.owner != current_user:\n flash(\"Failed to delete category %s since you are not the owner.\" %\n category.name)\n return redirect(url_for('.index'))\n\n form = DeleteForm()\n if form.validate_on_submit():\n try:\n db.session.delete(category)\n db.session.commit()\n except:\n flash((\"Failed to delete category \\\"%s\\\".\") % category.name)\n else:\n flash(\"Category \\\"%s\\\" has been deleted.\" % category.name)\n finally:\n return redirect(url_for('.index'))\n return render_template('delete.html', form=form, name=category_name)","def delete_category(category_id):\n\n category = Category.query.filter(\n Category.id == category_id,\n Category.user_id == current_user.id\n ).first()\n\n if not category:\n flash(\"Couldn't find that category\", category='warning')\n return redirect(request.referrer)\n\n category_name = category.name\n db.session.delete(category)\n db.session.commit()\n flash(\n \"Successfully deleted category '{}'\".format(category_name),\n \"success\")\n\n return redirect(url_for('url.index'))","def delete_category(self, category: str) -> None:\n for letter in self.data:\n if category in self.data[letter]:\n self.data[letter].pop(category)\n print(f'Categoria: {category} apagada do dicionário.')\n self.save()\n self.beautify_json()","def deleteCategory(category_id):\n\n categoryToDelete = session.query(Category).filter_by(\n id=category_id).first()\n\n if categoryToDelete.user_id != login_session['user_id']:\n flash(\"You are authorised to delete category created by You!\")\n return redirect(url_for('showCatalog'))\n\n if request.method == 'POST':\n session.delete(categoryToDelete)\n session.commit()\n flash('%s Successfully Deleted' % categoryToDelete.name)\n return redirect(url_for('showCatalog'))\n else:\n return render_template('deletecategory.html',\n category=categoryToDelete)","def destroy(self, request, *args, **kwargs):\n response = super(CategoryViewSet, self).destroy(request, *args, **kwargs)\n response.data = {'message': 'Categoria ha sido eliminada'}\n return response","def deleteCategory(category_id):\n\n if 'username' not in login_session:\n return redirect('/login')\n\n categoryToDelete = session.query(Category).filter_by(id=category_id).one()\n if categoryToDelete.user_id != login_session['user_id']:\n flash('You are not the creator of %s category, and cannot modify it' %\n categoryToDelete.name)\n return redirect(url_for('showCategories'))\n else:\n if request.method == 'POST':\n if \"btn_delete\" in request.form:\n session.delete(categoryToDelete)\n flash('%s Successfully Deleted' % categoryToDelete.name)\n session.commit()\n return redirect(url_for('showCategories'))\n else:\n return redirect(url_for('showCategories'))\n else:\n return render_template('deleteCategory.html',\n category=categoryToDelete,\n user=getUserInfo(login_session['user_id']))","def test_delete(self, init_db, category):\n category.delete()\n assert Category.get(category.id) == None","def deleteCategory(request, category_id):\n try:\n category = Category.objects.get(id=category_id)\n print(\"id\", category)\n except Category.DoesNotExist:\n return Response({'message': \"requested category does not exist\", \"status\": status.HTTP_404_NOT_FOUND})\n\n if request.method == \"GET\":\n serializer = CategorySerializer(category)\n return Response({\"data\": serializer.data, \"status\": status.HTTP_200_OK})\n\n elif request.method == \"DELETE\":\n category.delete()\n return Response({\"message\": \"Catagory deleted successfully\", \"status\": status.HTTP_200_OK})","def test_delete_category(self):\n rv = self.client().post(\n '/categories/',\n data={'category_name': 'Sauces'})\n self.assertEqual(rv.status_code, 201)\n res = self.client().delete('/categories/1')\n #self.assertEqual(res.status_code, 200)\n # Test to see if it exists, should return a 404\n result = self.client().get('/categories/1')\n #self.assertEqual(result.status_code, 404)","async def remove(self, ctx, cat: str, *, item: str):\n c = check_category(cat)\n if not c[0]:\n await ctx.send(\"`{}` isn't a category you can add things to.\".format(cat))\n return\n else:\n data = c[1]\n datafile = c[2]\n cat = c[3]\n \n user = ctx.author.name + \"#\" + ctx.author.discriminator\n if user not in data:\n await ctx.send(\"You haven't added anything to your {} list.\".format(cat))\n else:\n things = [x.strip() for x in item.split(',')]\n success = \"\"\n failure = \"\"\n for thing in things:\n try:\n data[user].remove(thing.title())\n success += \"`{}` was removed from your {} list.\\n\".format(thing.title(), cat)\n except:\n failure += \"You don't have a `{}` in your {} list.\\n\".format(thing.title(), cat)\n try:\n await ctx.send(success)\n except:\n pass\n try:\n await ctx.send(failure)\n except:\n pass\n pickle.dump(data, open(datafile, \"wb\"))","def delete(self, id):\n category = Categories.query.get(id)\n admin = get_jwt_claims()\n if category is None:\n return {'status': 'Not Found'}, 404, {'Content_Type': 'application/json'}\n\n db.session.delete(category)\n db.session.commit()\n return {\"Status\": \"The data with id {} is deleted\".format(id)}, 200, {'Content_Type': 'application/json'}","async def delete_category(self, category):\n stmt = delete(self.model)\n\n if self.category_field:\n stmt = stmt.where(getattr(self.model, self.category_field) == category)\n\n self.session.execute(stmt)","def destroy(self, request, pk=None):\n\n if not request.auth.user.is_staff:\n return Response(\n {'message': 'You must be an admin to delete categories.'},\n status=status.HTTP_403_FORBIDDEN\n )\n\n try:\n category = Categories.objects.get(pk=pk)\n\n except Categories.DoesNotExist:\n return Response(\n {'message': 'There is no category with the specified ID.'},\n status=status.HTTP_404_NOT_FOUND\n )\n\n if category.label == 'Uncategorized':\n return Response(\n {'message': 'Deleting the `Uncategorized` category is forbidden.'},\n status=status.HTTP_403_FORBIDDEN\n )\n\n category.delete()\n return Response({}, status=status.HTTP_204_NO_CONTENT)","def test_delete_category(self):\n self.add_success(self.test_data['pants'])\n self.delete_success('pants')","def test_category_delete(category):\n category.delete()\n\n category = Category.query.filter_by(id=category.id).first()\n\n assert category is None","def delete_category(self, category_id, user_id):\r\n category = self._db_manager.get_category(category_id)\r\n if category is None:\r\n flash(\"Invalid category.\")\r\n return\r\n if category[\"user_id\"] != user_id:\r\n flash(\"Only the original creator can delete a category.\")\r\n return\r\n flash(self._db_manager.delete_category(category_id))","def delete(self):\r\n self.domain.delete_item(self)","def delete_item(request):\n if request.json_body[u'type'] == u'post':\n if DBSession.query(Post).filter(Post.name==request.json_body[u'name']).delete() == 1:\n return {\"deletion_status\":\"success\"}\n import ipdb; impdb.set_trace()\n return {\"deletion_status\":\"error\"}","async def delete_recipe_category(category: str, session: Session = Depends(generate_session)):\n\n try:\n db.categories.delete(session, category)\n except Exception:\n raise HTTPException(status.HTTP_400_BAD_REQUEST)","def delete_category(category_id):\n if request.args.get('state') != login_session['state']:\n response = make_response(\n json.dumps({'error': 'Invalid state parameter.'}), 401\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n if 'username' not in login_session:\n response = make_response(\n json.dumps({'error': 'User is logged out. This should not happen'}), 401\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n try:\n if request.method == 'DELETE':\n category = session.query(Category).filter_by(id=category_id).one()\n session.delete(category)\n session.commit()\n state = get_new_state()\n login_session['state'] = state\n response = make_response(\n json.dumps({'success': '', 'nonce': login_session['state']}), 200\n )\n response.headers['Content-Type'] = 'application/json'\n return response\n except Exception as inst:\n print(type(inst))\n print(inst.args)\n print(inst)","def test_category_delete(self):\n login = self.autheniticate()\n token = json.loads(login.data.decode()).get('token')\n self.app.post(category_url,\n data=json.dumps(self.data),\n headers=dict(Authorization=\"Bearer \" + token),\n content_type='application/json')\n res = self.app.delete('/api/v2/categories/1',\n headers=dict(Authorization=\"Bearer \" + token),\n content_type='application/json')\n res1 = json.loads(res.data.decode())\n self.assertEqual(res1['status'], 'Deleted!')\n self.assertEqual(res.status_code, 200)","def delete_recipe_category(db_id):\r\n\r\n # determines the category name by id\r\n category_name = mongo.db.recipe_categories.find_one(\r\n {'_id': ObjectId(db_id)})['name']\r\n\r\n # removes all the recipes in the category\r\n mongo.db.recipes.remove({'category': category_name})\r\n\r\n # removes the recipe category\r\n mongo.db.recipe_categories.remove({'_id': ObjectId(db_id)})\r\n\r\n # redirects to the recipe category search\r\n return redirect(url_for(\r\n 'search',\r\n collection='recipe_categories')\r\n )","def _delete(self, item):\n self.cv.delete(item)","def delete(current_user, self, category_id, recipe_id):\n if not current_user:\n return is_unauthorized()\n\n category = current_user.categories.filter_by(id=category_id).first()\n if category:\n selected_recipe = category.recipes.filter_by(id=recipe_id).first()\n # When the recipe requested does not exist\n if not selected_recipe:\n return _does_not_exist()\n name = selected_recipe.name\n # Delete the selected recipe\n db.session.delete(selected_recipe)\n db.session.commit()\n # Render response\n response_payload = {\n \"message\": \"Recipe \" + name + \" was deleted successfully!\"\n }\n response_payload = jsonify(response_payload)\n return make_response(response_payload, 200)\n # When an invalid category id is provided\n response_payload = dict(\n message='Category does not exist!'\n )\n response_payload = jsonify(response_payload)\n return make_response(response_payload, 404)","def render_delete_category_page(\r\n self, client_id, state, user_id, user_name, category_id):\r\n category = self._db_manager.get_category(category_id)\r\n if category is None:\r\n flash(\"Invalid category.\")\r\n return\r\n if category[\"user_id\"] != user_id:\r\n flash(\"Only the original creator can delete a category.\")\r\n return\r\n return render_template(\r\n \"category_delete.html\",\r\n client_id=client_id,\r\n state=state,\r\n is_logged_in=True,\r\n user_name=user_name,\r\n category=category\r\n )","def destroy(self, request, pk=None):\n current_user = User.objects.get(id=request.user.id)\n if current_user.is_staff:\n try:\n category = Category.objects.get(pk=pk)\n category.delete()\n return Response({}, status=status.HTTP_204_NO_CONTENT)\n except Category.DoesNotExist:\n return Response({\"reason\": \"Doesn't Exist\"}, status=status.HTTP_400_BAD_REQUEST)\n else:\n return Response({'message': 'Stop, seriously, just stop. You are not an admin'},\n status=status.HTTP_403_FORBIDDEN)","def delete_item(request, product_id):\n\n if not request.user.is_superuser:\n messages.error(request, 'Sorry, you are not permitted to do that.')\n return redirect(reverse('home'))\n\n product = get_object_or_404(Product, pk=product_id)\n product.delete()\n messages.success(request, 'You have deleted the item!')\n return redirect(reverse('items'))","def remove_item(item_id):\n remove_item = session.query(Item).filter_by(id=item_id).one()\n category_id = remove_item.category_id\n\n # redirect to details page if current user does not own item\n if remove_item.user_id != login_session['user_id']:\n return redirect(\n url_for(\n 'item_details',\n category_id=category_id,\n item_id=remove_item.id))\n\n if request.method == 'POST':\n session.delete(remove_item)\n session.commit()\n return redirect(\n url_for(\n 'items_for_category', category_id=category_id))\n else:\n return render_template(\n 'views/delete.html',\n item_to_delete=remove_item,\n category_id=category_id)","def delete_item(self):\n\n\t\tdb.session.delete(self)\n\t\tdb.session.commit()","def excluir_categoria():\n try:\n if current_user.is_administrator():\n cod_id = request.args.get('id')\n categoria = Categoria.query.filter_by(cod_categoria = cod_id).one()\n db.session.delete(categoria)\n db.session.commit()\n return listar_questoes()\n return redirect(url_for('admin.listar_questoes'))\n except Exception as e:\n abort(500, e)","def delete_item(request, shoppinglist_id, item_id):\n Item.objects.filter(pk=item_id,\n shoppinglist__pantry__owner=request.user).delete()\n return redirect('shoppinglists.views.detail', shoppinglist_id)","def delete_item(item_id):\n\n item = Item.query.filter(\n Item.id == item_id,\n Item.user_id == current_user.id\n ).first()\n\n if not item:\n flash(\"Couldn't find the item\", category='warning')\n return redirect(request.referrer)\n\n item_name = item.name\n db.session.delete(item)\n db.session.commit()\n flash(\n \"Successfully deleted item '{}'\".format(item_name),\n \"success\")\n\n return redirect(url_for('url.index'))","def delete_item(item_name):\n\n item = Item.query.filter_by(name=item_name).first_or_404()\n if item.owner != current_user:\n flash(\"Failed to delete item %s since you are not the owner.\" %\n item.name)\n return redirect(url_for('.index'))\n\n form = DeleteForm()\n if form.validate_on_submit():\n try:\n db.session.delete(item)\n db.session.commit()\n except:\n flash((\"Failed to delete item \\\"%s\\\".\") % item.name)\n else:\n flash(\"Item \\\"%s\\\" has been deleted.\" % item.name)\n finally:\n return redirect(url_for('.index'))\n return render_template('delete.html', form=form, name=item_name)","def delete(self, something):\n if something == Concept:\n number = 0\n target_list = self.concept_list\n elif something == Subcategory:\n number = 1\n target_list = self.concept_list\n elif something == Relation:\n number = 2\n target_list = self.relation_list\n if target_list.currentIndex().isValid():\n something = target_list.selectedItems()[0].data(Qt.UserRole)[number]\n self.db.delete(something)\n self.search()","def delete_item(item_name):\n item = Item.query.filter_by(name=item_name).first()\n\n # If the URL contains a bad item name, send a 404\n if not item:\n abort(404)\n\n # If the current user is not authorized to delete the item because\n # the item was created by a different user, send a 403\n elif current_user != item.user:\n abort(403)\n\n form = DeleteItemForm()\n\n # If the form is submitted, delete the item from the database,\n # send a flash message, and redirect home\n if form.validate_on_submit():\n db.session.delete(item)\n db.session.commit()\n flash(f'\"{item.name}\" has been deleted.', 'good')\n return redirect(url_for('main.home'))\n\n return render_template('delete_item.html', item=item, form=form)","def test_delete_recipe_category(self):\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\n self.login('Bo_theo5@example.com', 'Bo1995')\n self.dashboard()\n self.category('JunkFood')\n self.dashboard()\n self.recipe_dashboard()\n self.create_recipe('cakes', 'blah, blah, blah....mix ingredient, heat')\n self.edit_recipe('edited cakes', 'edited blah blah blah spoon , heat')\n rv = self.del_recipe()\n self.assertIn(b'deleted successfully', rv.data)","def do_del_item(self, arg):\n try:\n del_item = arg[\"<list_name>\"]\n choice = arg[\"--choice\"]\n if choice == \"name\":\n del_item_str = \" \".join(del_item)\n print(del_item_str)\n elif choice == \"id\":\n del_item_str = int(\" \".join(del_item))\n print (del_item_str)\n app.ToDoApp.to_delete_item(del_item_str)\n print (\"Item deleted\")\n\n\n \n except ValueError as e:\n cprint((e), 'red')","def delete_item(self, id: str, user: User) -> bool:","def deleteCategory(category_id):\r\n # authentication\r\n if 'username' not in login_session:\r\n flash('Please login to edit category')\r\n return redirect(url_for('showCategories'))\r\n\r\n # validation\r\n deletedCategory = session.query(Category).filter_by(id=category_id).first()\r\n if not deletedCategory:\r\n flash('Attempt to delete non-existent category')\r\n return redirect(url_for('showCategories'))\r\n\r\n # authorization\r\n if login_session['user_id'] != deletedCategory.user_id:\r\n flash('Sorry, you are not authorized to delete the category \\'{}\\''\r\n .format(deletedCategory.name))\r\n return redirect(url_for('showCategories'))\r\n\r\n # delete operation\r\n if request.method == 'POST':\r\n session.delete(deletedCategory)\r\n session.commit()\r\n flash('Deleted Category \\'{}\\' Successfully'.format(\r\n deletedCategory.name))\r\n return redirect(url_for('showCategories'))\r\n else:\r\n # serve GET requests with confirmation form\r\n return render_template(\"deleteCategory.html\", category=deletedCategory)","def test_delete_category_does_not_exist(self):\n self.delete_does_not_exist_fail('hats')","def delete(self):\n response = settings.database.delete_item(Key={'id': str(self.id)})\n raise_for_response(response)","def delete(item_id):\n session = current_app.config['db']\n if request.method == \"POST\":\n used = session.query(func.count(WineType.id).label('count'))\\\n .filter_by(abv_id=item_id).scalar()\n item = session.query(WineABV).filter_by(id=item_id).one()\n c_name = item.name\n if used == 0:\n session.delete(item)\n session.commit()\n flash(\"Successfully Deleted '%s'\" % (c_name,), 'success')\n else:\n flash(\"'%s' is still in use and cannot be deleted.\" % (c_name,),\n 'danger')\n return redirect(url_for('.show'))\n\n else:\n item = session.query(WineABV).filter_by(id=item_id).one()\n return render_template(template_prefix+'delete_form.html', item=item)","def cfDel(self, key, item):\n params = [key, item]\n\n return self.execute_command(self.CF_DEL, *params)","def delete_one(id):\r\n # Get the category requested\r\n category = Category.query.filter(Category.id == id).one_or_none()\r\n\r\n if category is not None:\r\n sqlalc.session.delete(category)\r\n sqlalc.session.commit()\r\n return make_response(f\"The category {id} is deleted\", 200)\r\n\r\n else:\r\n abort(404, f\"Category not found for id: {id}\")","async def delete_category(self, category):\n await super(MemoryKVCache, self).delete_category(category)\n\n if self.in_transaction:\n self.dirty_categories.add(category)","def delete_item(id):\n return '', 201","def deleteItem(request, itemid):\n try:\n item = ItemSerializer(Item.objects.get(id=itemid))\n Item.objects.get(id=itemid).delete()\n return Response(item.data)\n\n except Item.DoesNotExist:\n fail = {\n \"item\":\"item does not exist\"\n }\n return JsonResponse(fail)","def delete(self, *args, **kwargs):\n pass","def delete(self, *args, **kwargs):\n pass","def remove_item_page(request):\n validate(instance=request.body, schema=item_schema_remove)\n body = json.loads(request.body)\n Item.remove_item(body['item_id'])\n return HttpResponse('success')","def delete(self, id_):\n \n db.categories.remove({'_id': ObjectId(id_)})\n return '', 204","def test_delete_single_recipe_category(self):\n with self.client:\n response = self.register_user(\n \"Patrick\", \"Walukagga\", \n \"pwalukagga@gmail.com\", \"telnetcmd123\"\n )\n # registered user login\n rep_login = self.login_user(\"pwalukagga@gmail.com\", \"telnetcmd123\")\n # valid token\n headers=dict(\n Authorization='Bearer ' + json.loads(\n rep_login.data.decode()\n )['auth_token']\n )\n cresponse = self.create_category(\"Breakfast\", \n \"How to make breakfast\", \n headers)\n \n response = self.create_category(\"Lunchfast\", \n \"How to make lunchfast\", \n headers)\n response = self.client.delete('/recipe_category/1', \n headers=headers)\n self.assertEqual(response.status_code, 200)\n self.assertIn('Recipe category deleted', \n str(response.data))\n # delete recipe category not in database\n response = self.client.delete('/recipe_category/3', \n headers=headers, )\n self.assertEqual(response.status_code, 404)\n self.assertIn('No category found', \n str(response.data))","async def delete_category(self, category: str) -> dict:\n async with self.lock:\n await self.storage.delete_category(category)\n return await self.cache.delete_category(category)","def delete(self, item, request):\n\n assert (\n isinstance(item, Election)\n or isinstance(item, ElectionCompound)\n or isinstance(item, Vote)\n )\n\n url = request.link(item)\n url = replace_url(url, request.app.principal.official_host)\n for result in self.query().filter_by(url=url):\n self.session.delete(result)\n\n self.session.delete(item)\n self.session.flush()","def test_delete_item_using_delete(self):\n pass","def render_delete_item_page(\r\n self, client_id, state, user_id, user_name, item_id):\r\n item = self._db_manager.get_item(item_id)\r\n if item is None:\r\n flash(\"Invalid item.\")\r\n return\r\n if item[\"user_id\"] != user_id:\r\n flash(\"Only the original creator can delete an item.\")\r\n return\r\n category = self._db_manager.get_category(item[\"category_id\"])\r\n if category is None:\r\n flash(\"Sorry, something went wrong.\")\r\n return\r\n return render_template(\r\n \"item_delete.html\",\r\n client_id=client_id,\r\n state=state,\r\n is_logged_in=True,\r\n user_name=user_name,\r\n category=category[\"name\"],\r\n item=item\r\n )","def item_delete(request):\n if request.method == 'POST':\n item_to_delete = get_object_or_404(StockItem, pk=request.POST['id'])\n item_to_delete.active = False\n item_to_delete.save()\n return HttpResponse(status=200)","def delete(self):\n return self.items.delete(item_id=self.id)","def deleteItem(sport_id, item_id):\n\n sport = session.query(Sport).filter_by(id=sport_id).one()\n deletedItem = session.query(Item).filter_by(id=item_id).one()\n if request.method == 'POST':\n session.delete(deletedItem)\n session.commit()\n return redirect(url_for('showSports'))\n else:\n return render_template('deleteitem.html', sport_id=sport_id,\n item_id=item_id, sport=sport, item=deletedItem)","def delete(request, itemID):\n\ttry:\n\t\titem = get_object_or_404(Item, itemID = itemID)\n\n\t# Handle when the given itemID is not a UUID\n\texcept ValidationError:\n\t\traise Http404\n\n\tif item.seller.user != request.user:\n\t\traise Http404\n\t\n\titem.delete()\n\treturn HttpResponseRedirect(reverse('tailored:index'))","def delete_recipe(db_id):\r\n\r\n # keeps recipe category link\r\n category = mongo.db.recipes.find_one(\r\n {'_id': ObjectId(db_id)})['category']\r\n\r\n # removes recipe\r\n mongo.db.recipes.remove({'_id': ObjectId(db_id)})\r\n\r\n # updates counter in the category\r\n update_quantity_in_category(category)\r\n\r\n # redirects to the recipes in the same category\r\n return redirect(url_for(\r\n 'search',\r\n collection='recipes',\r\n find=category)\r\n )","def post_delete(self, *args, **kw):\n #obtenemos el id de la fase para hacer el filtrado despues de la redireccion\n item_to_del = DBSession.query(Item).filter_by(id_item=args[0]).one()\n fid = item_to_del.id_fase_fk\n pks = self.provider.get_primary_fields(self.model)\n d = {}\n for i, arg in enumerate(args):\n d[pks[i]] = arg\n self.provider.delete(self.model, d)\n\n path = './' + '../' * (len(pks) - 1) + '?fid=' + str(fid)\n\n redirect(path)","def post_delete(self, *args, **kw):\n id_atributo = int(args[0])\n transaction.begin()\n attr = AtributosPorTipoItem.por_id(id_atributo)\n DBSession.delete(attr)\n transaction.commit()\n flash(\"Atributo Eliminado\")\n redirect(\"./\")","def delete_item_details(item_id):\n item = is_user_the_creator(item_id)\n item_name = item.Item.name\n if request.method == 'GET':\n return render_template('item_delete_confirm.html', item_name=item_name, item_id=item_id,\n login_session=login_session,\n csrf_token=generate_csrf_token())\n else:\n session.delete(item.Item)\n session.commit()\n flash(item_name + \" deleted\")\n return redirect(url_for('show_homepage'))","def on_delete(action, item, view):\n actors.remove(action.actor)\n self.remove(item)","def delete_item(self):\n self.df_user.drop(self.index_select_number, inplace=True)\n self.df_user.to_csv(\"user_items.csv\", index=False)\n self.update_treeview()\n self.changing_item_label.config(text=\"Please double click on the item you want to edit.\")\n self.delete_but.destroy()\n self.serv_drop.destroy()\n self.serv_but.destroy()\n self.pop_up_del.destroy()","def delete(self):\n ...","def delete_item_wishlist():\n curItem = wishlist_treeview.focus().strip('#')\n\n with open(\"Other_title_categories.json\", \"r\") as other_categories_fo:\n other_categories_foData = json.load(other_categories_fo)\n completeDict = other_categories_foData[\"wish_list\"]\n selectetItemData_complete = completeDict[curItem]\n\n print(\"deleting : \", curItem)\n\n del completeDict[curItem]\n other_categories_foData[\"wish_list\"] = completeDict\n\n with open('Other_title_categories.json', 'w') as f:\n json.dump(other_categories_foData, f, indent=2)\n print(\"done deleting the title \", curItem)\n\n wishlist_treeview.delete(wishlist_treeview.focus())","def delete_entry():\n if not check_admin_logged() :\n abort(403)\n\n title = request.args.get('title', default='')\n category = request.args.get('category', default='')\n buydate = request.args.get('buydate', default='')\n ssid = decrypt_book_record(request.args.get('ssid'))\n\n pre_delete_entry = Entries.query.filter_by(\n id=ssid, title=title, category=category, \\\n buydate=buydate).first()\n\n if pre_delete_entry is not None :\n try :\n db.session.delete(pre_delete_entry)\n db.session.commit()\n flash(u'删除成功')\n except InvalidRequestError as e :\n log_error('error when delete:')\n log_error(e.message)\n #log_error(u'when delete item %s ' % str(pre_delete_entry))\n # DO NOT use the above one for the F UnicodeEncodeError\n log_error(u'when delete item %s ' % pre_delete_entry)\n db.session.flush()\n flash(u'因为数据库操作原因，删除失败')\n else :\n flash(u'删除失败')\n\n return redirect(url_for('show_entries_admin'))","def delete():\n id_num = int(input('Enter the ID number of the item you wish to delete\\n'))\n db_actions.remove(id_num)","def del_category(self, category):\n if category in self.categories:\n self.categories.remove(category)","def test_delete_a_category_invalid_token(self):\n self.test_add_category_success()\n token = \"\"\n response = self.client.delete('/categories/1',\n headers={\"Authorization\": token})\n self.assertEqual(response.status_code, 401)\n self.assertIn('Token not found', response.data.decode())"],"string":"[\n \"def category_delete(request):\\n if request.POST:\\n cat = get_object_or_404(Category, pk=request.POST.get('id'))\\n cat.delete()\\n return HttpResponse(status=200)\",\n \"def deleteCategory():\\n deletecategory = deleteCategoryForm()\\n # Look for CSRF token in form, verify POST method, and validate form data.\\n if deletecategory.validate_on_submit():\\n deleteID = deletecategory.deleteID.data\\n category = Category.query.filter_by(id=deleteID).one()\\n # Check logged in user against the category creator.\\n if session['user_id'] == category.user_id:\\n items = Item.query.filter_by(category=category.id)\\n # Delete items related to category as well as category itself.\\n if items:\\n for i in items:\\n db.session.delete(i)\\n db.session.delete(category)\\n db.session.commit()\\n return redirect(url_for('index'))\\n else:\\n return redirect(url_for('index'))\\n else:\\n return redirect(url_for('index'))\",\n \"def deleteCategory(category_id):\\n editedCategory = session.query(Category).\\\\\\n filter_by(id=category_id).one()\\n editedItem = session.query(Item).\\\\\\n filter_by(category_id=editedCategory.id).all()\\n print editedItem\\n if editedCategory.user_id != login_session['user_id']:\\n flash('You are not authorized to delete this Item.\\\\\\n Please create own Category with items in order to \\\\\\n delete items.')\\n return redirect(url_for('showallCategories'))\\n else:\\n if editedItem:\\n flash('Category Deletion not possible. \\\\\\n Please delete the items in Category')\\n return redirect(url_for('showCategory',\\n category_id=category_id))\\n elif request.method == 'POST':\\n session.delete(editedCategory)\\n session.commit()\\n flash('Category Deletion successfull')\\n return redirect(url_for('showallCategories'))\\n else:\\n return render_template(\\n 'deleteCategory.html', category_id=category_id,\\n category=editedCategory)\",\n \"def deleteListItem(category_id, item_id):\\n\\n if 'username' not in login_session:\\n return redirect('/login')\\n\\n category = session.query(Category).filter_by(id=category_id).one()\\n itemToDelete = session.query(ListItem).filter_by(id=item_id).one()\\n\\n if category.user_id != login_session['user_id']:\\n flash('You are not the creator of %s category, and cannot modify it' %\\n category.name)\\n return redirect(url_for('showItems', category_id=category.id))\\n\\n if request.method == 'POST':\\n if \\\"btn_delete\\\" in request.form:\\n session.delete(itemToDelete)\\n session.commit()\\n flash('Catalog Item Successfully Deleted')\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return redirect(url_for('showItems', category_id=category_id))\\n else:\\n return render_template('deleteitem.html',\\n item=itemToDelete,\\n user=getUserInfo(login_session['user_id']))\",\n \"def deleteItem(category_id, item_id):\\n category = session.query(Category).filter_by(id=category_id).first()\\n item = session.query(Item).filter_by(id=item_id).first()\\n if item.user_id != login_session['user_id']:\\n flash(\\\"You are authorised to delete items created by you!\\\")\\n return redirect(url_for(\\\"showCatalog\\\"))\\n if request.method == \\\"POST\\\":\\n session.delete(item)\\n session.commit()\\n flash('%s Item Successfully Deleted' % (item.name))\\n return redirect(url_for('showItem', category_id=item.category_id))\\n else:\\n return render_template(\\\"deleteitem.html\\\", item=item,\\n category=category)\",\n \"def deleteItem(category_id, item_id):\\n editedItem = session.query(Item).filter_by(id=item_id).one()\\n if editedItem.user_id != login_session['user_id']:\\n flash('You are not authorized to delete this Item.\\\\\\n Please create own Category with items in order to \\\\\\n delete items.')\\n return redirect(url_for('showallCategories'))\\n if request.method == 'POST':\\n session.delete(editedItem)\\n session.commit()\\n flash('Item Deletion successfull')\\n return redirect(url_for('showCategory', category_id=category_id))\\n else:\\n return render_template(\\n 'deleteItem.html', category_id=category_id,\\n item_id=item_id, item=editedItem)\",\n \"def delete_item(category, item):\\n # Verify user login. If not, redirect to login page.\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n else:\\n flash('Please log in.')\\n return redirect(url_for('home'))\\n if request.method == 'POST':\\n # Query database with SQLAlchemy and store queries as objects\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n item = (session.query(Items)\\n .filter_by(name=item\\n .replace('-', ' '), category_id=category.id)\\n .one())\\n # Get user's database ID\\n user_db_id = (session.query(Users)\\n .filter_by(email=login_session['email'])\\n .one()).id\\n # Get database ID of creator\\n creator_db_id = item.creator_db_id\\n print(\\\"Current user's database primary key id is {}.\\\"\\n .format(user_db_id))\\n print(\\\"Item creator's database primary key id is {}.\\\"\\n .format(creator_db_id))\\n print('Item to delete is \\\"{}\\\".'.format(item.name))\\n # Only allow creator to edit. If not, redirect to login.\\n if user_db_id != creator_db_id:\\n flash('Only the creator can edit. Please log in as creator.')\\n return redirect(url_for('home'))\\n session.delete(item)\\n session.commit()\\n # Return to homepage\\n return redirect(url_for('home'))\\n else:\\n # Render webpage\\n return render_template('delete_item.html',\\n item=item,\\n login_status=login_status)\",\n \"def delete_item(item_name, catagory_name):\\n try:\\n item = Item.fetch_by_name_and_catagory_name(item_name, catagory_name)\\n except NoResultFound:\\n abort(404)\\n item.delete()\\n return redirect(url_for('home'))\",\n \"def delete_category_item(category_item_id):\\n item = session.query(CatalogItem).filter_by(id=category_item_id).one()\\n session.delete(item)\\n session.commit()\",\n \"def delete(self):\\n key = self.request.get('key')\\n\\n if not self.assert_xsrf_token_or_fail(\\n self.request, 'delete-category', {}):\\n return\\n\\n if not roles.Roles.is_super_admin():\\n transforms.send_json_response(\\n self, 401, 'Access denied.')\\n return\\n\\n errors = []\\n course_category.CourseCategoryDAO.delete_category(key, errors)\\n if not errors:\\n transforms.send_json_response(self, 200, 'Deleted.')\\n else:\\n transforms.send_json_response(self, 412, '\\\\n'.join(errors))\",\n \"def delete_category(self):\\n index_list = self.categoriesView.selectedIndexes()\\n if index_list and index_list[0].isValid():\\n index = index_list[0]\\n category = index.data(Qt.UserRole)\\n\\n deletion = self.orm.delete_category(category)\\n if not deletion:\\n show_warning(\\\"Can't delete category\\\")\\n else:\\n self.show_categories()\\n if category.parent is None:\\n self.show_available_parents()\",\n \"def delete_category(category):\\n # Verify user login. If not, redirect to login page.\\n login_status = None\\n if 'email' in login_session:\\n login_status = True\\n else:\\n flash('Please log in.')\\n return redirect(url_for('home'))\\n if request.method == 'POST':\\n # Query database with SQLAlchemy and store queries as objects\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n category_items = (session.query(Items)\\n .filter_by(category_id=category.id)\\n .order_by(Items.name)\\n .all())\\n # Get user's database ID\\n user_db_id = (session.query(Users)\\n .filter_by(email=login_session['email'])\\n .one()).id\\n # Get database ID of category creator\\n creator_db_id = category.creator_db_id\\n print(\\\"Current user's database primary key id is {}.\\\"\\n .format(user_db_id))\\n print(\\\"Category creator's database primary key id is {}.\\\"\\n .format(creator_db_id))\\n print('Category to delete is \\\"{}\\\".'.format(category.name))\\n print('Items to delete:')\\n for item in category_items:\\n print(item.name)\\n # Only allow creator to edit. If not, redirect to login.\\n if user_db_id != creator_db_id:\\n flash('Only the creator can edit. Please log in as creator.')\\n return redirect(url_for('home'))\\n session.delete(category)\\n for item in category_items:\\n session.delete(item)\\n session.commit()\\n # Return to homepage\\n return redirect(url_for('home'))\\n else:\\n # Render webpage\\n return render_template('delete_category.html',\\n category_name=category,\\n login_status=login_status)\",\n \"def deleteItem(category_id, item_id):\\r\\n # authentication\\r\\n if 'username' not in login_session:\\r\\n flash('Please login to add item')\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n # validation\\r\\n category = session.query(Category).filter_by(id=category_id).first()\\r\\n if not category:\\r\\n flash('Attempted operation on non-existent category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n deletedItem = session.query(Item).\\\\\\r\\n filter_by(id=item_id, category_id=category_id).first()\\r\\n if not deletedItem:\\r\\n flash('Attempt to delete non-existent item')\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n # authorization\\r\\n if login_session['user_id'] != deletedItem.user_id:\\r\\n flash('Sorry, you are not authorized to delete the item \\\\'{}\\\\''\\r\\n .format(deletedItem.name))\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n\\r\\n if request.method == 'POST':\\r\\n # delete operation\\r\\n session.delete(deletedItem)\\r\\n session.commit()\\r\\n flash('Deleted Item \\\\'{}\\\\' Successfully'.format(deletedItem.name))\\r\\n return redirect(url_for('showItems', category_id=category_id))\\r\\n else:\\r\\n # serve GET requests with confirmation form\\r\\n return render_template(\\\"deleteItem.html\\\",\\r\\n category=deletedItem.category, item=deletedItem)\",\n \"def delete_category(request, id):\\n\\n if request.method == \\\"POST\\\":\\n Category.objects.get(id=id).delete()\\n messages.success(request, \\\"Category deleted successfully.\\\")\\n return redirect(\\\"category\\\")\\n\\n return render(request, \\\"core/delete_category.html\\\", {\\n \\\"object\\\": Category.objects.get(id=id)\\n })\",\n \"def delete_item(category, name):\\r\\n item_key = course_key.make_usage_key(category, name)\\r\\n resp = self.client.delete(get_url('xblock_handler', item_key))\\r\\n self.assertEqual(resp.status_code, 204)\\r\\n _test_no_locations(self, resp, status_code=204, html=False)\",\n \"def delete_category(category_id):\\n mongo.db.categories.remove({\\\"_id\\\": ObjectId(category_id)})\\n flash(\\\"Recipe was deleted\\\")\\n return redirect(url_for(\\\"get_categories\\\"))\",\n \"def delete_category(key):\\n try:\\n category = Categories.objects.get(pk=key)\\n except ObjectDoesNotExist:\\n return Response({'status': CATEGORY_NOT_FOUND}, status=status.HTTP_404_NOT_FOUND)\\n\\n setattr(category, 'is_delete', True)\\n category.save()\\n return Response({'status': CATEGORY_DELETED}, status=status.HTTP_200_OK)\",\n \"def delete(id):\\r\\n\\r\\n category = Category.query.get_or_404(id)\\r\\n db.session.delete(category)\\r\\n db.session.commit()\\r\\n flash('You have successfully deleted the category.')\\r\\n\\r\\n # redirect to the category page\\r\\n return redirect(url_for('category.list'))\",\n \"def delete_category(request):\\n try:\\n categories = request.POST.getlist('category_id', 0)\\n category = Category.objects.filter(pk__in=categories).delete()\\n ActionLogger().log(request.user, \\\"deleted\\\", \\\"Knowledgebase Category %s\\\" % categories)\\n return format_ajax_response(True, \\\"Knowledgebase category(s) deleted successfully.\\\")\\n except Exception as ex:\\n logger.error(\\\"Failed to delete_category: %s\\\" % ex)\\n return format_ajax_response(False, \\\"There was an error deleting knowledgebase category(s).\\\")\",\n \"def deleteCategory(category_id):\\r\\n if 'username' not in login_session:\\r\\n return redirect(url_for('showLogin'))\\r\\n session = DBSession()\\r\\n deletedCategory = session.query(Category).filter_by(id=category_id).one()\\r\\n if deletedCategory.user_id != login_session['user_id']:\\r\\n return \\\"<script>function myFunction() {alert('You are not authorized to delete this category.');}</script><body onload='myFunction()''>\\\"\\r\\n if request.method == 'POST':\\r\\n session.delete(deletedCategory)\\r\\n deletedItems = session.query(Item).filter_by(\\r\\n category_id=category_id).all()\\r\\n for i in deletedItems:\\r\\n session.delete(i)\\r\\n session.commit()\\r\\n return redirect(url_for('showCategories'))\\r\\n else:\\r\\n return render_template('deletecategory.html', category=deletedCategory)\",\n \"def delete_item(item_id):\\n if 'userinfo' not in session.keys():\\n session['target'] = url_for('delete_item', item_id=item_id)\\n return redirect(url_for('gconnect'))\\n if request.method == 'POST':\\n sqlsession = SQLSESSION()\\n item = sqlsession.query(Item).filter_by(id=item_id).first()\\n sqlsession.delete(item)\\n sqlsession.commit()\\n return redirect(\\\"/\\\")\\n sqlsession = SQLSESSION()\\n item = sqlsession.query(Item, Category).join(Category)\\\\\\n .filter(Item.id == item_id).first()\\n return render_template(\\\"delete_item.html\\\", item=item)\",\n \"def delete_recipe_category(title):\\n result = USERS[session['username']].delete_recipe_category(title)\\n if result == \\\"recipe category deleted\\\":\\n flash(result, 'info')\\n else:\\n flash(result, 'warning')\\n return redirect(url_for('categories'))\",\n \"def delete_item_page(item_name, catagory_name):\\n return render_template(\\n 'delete_item.html', item_name=item_name, catagory_name=catagory_name\\n )\",\n \"def test_delete_a_category(self):\\n self.test_add_category_success()\\n response = self.client.delete('/categories/1',\\n headers={\\\"Authorization\\\": self.token})\\n self.assertEqual(response.status_code, 200)\\n self.assertIn('category deleted permanently',\\n response.data.decode())\",\n \"def delete(self, item):\\n self._createAction(item, \\\"delete\\\")\",\n \"def deleteItem(category_id, item_id):\\r\\n if 'username' not in login_session:\\r\\n return redirect(url_for('showLogin'))\\r\\n session = DBSession()\\r\\n deletedItem = session.query(Item).filter_by(id=item_id).one()\\r\\n if deletedItem.user_id != login_session['user_id']:\\r\\n return \\\"<script>function myFunction() {alert('You are not authorized to delete this item.');}</script><body onload='myFunction()''>\\\"\\r\\n if request.method == 'POST':\\r\\n session.delete(deletedItem)\\r\\n session.commit()\\r\\n return redirect(url_for('showCategoryItems', category_id=category_id))\\r\\n else:\\r\\n return render_template('deleteitem.html', item=deletedItem)\",\n \"def test_delete_category(self):\\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\\n self.login('Bo_theo5@example.com', 'Bo1995')\\n self.dashboard()\\n self.category('JunkFood')\\n self.dashboard()\\n rv = self.del_category()\\n self.assertIn(b'successfully deleted category', rv.data)\",\n \"def test_delete_category(self):\\n pass\",\n \"def delete_category(category_name):\\n\\n category = Category.query.filter_by(name=category_name).first_or_404()\\n if category.owner != current_user:\\n flash(\\\"Failed to delete category %s since you are not the owner.\\\" %\\n category.name)\\n return redirect(url_for('.index'))\\n\\n form = DeleteForm()\\n if form.validate_on_submit():\\n try:\\n db.session.delete(category)\\n db.session.commit()\\n except:\\n flash((\\\"Failed to delete category \\\\\\\"%s\\\\\\\".\\\") % category.name)\\n else:\\n flash(\\\"Category \\\\\\\"%s\\\\\\\" has been deleted.\\\" % category.name)\\n finally:\\n return redirect(url_for('.index'))\\n return render_template('delete.html', form=form, name=category_name)\",\n \"def delete_category(category_id):\\n\\n category = Category.query.filter(\\n Category.id == category_id,\\n Category.user_id == current_user.id\\n ).first()\\n\\n if not category:\\n flash(\\\"Couldn't find that category\\\", category='warning')\\n return redirect(request.referrer)\\n\\n category_name = category.name\\n db.session.delete(category)\\n db.session.commit()\\n flash(\\n \\\"Successfully deleted category '{}'\\\".format(category_name),\\n \\\"success\\\")\\n\\n return redirect(url_for('url.index'))\",\n \"def delete_category(self, category: str) -> None:\\n for letter in self.data:\\n if category in self.data[letter]:\\n self.data[letter].pop(category)\\n print(f'Categoria: {category} apagada do dicionário.')\\n self.save()\\n self.beautify_json()\",\n \"def deleteCategory(category_id):\\n\\n categoryToDelete = session.query(Category).filter_by(\\n id=category_id).first()\\n\\n if categoryToDelete.user_id != login_session['user_id']:\\n flash(\\\"You are authorised to delete category created by You!\\\")\\n return redirect(url_for('showCatalog'))\\n\\n if request.method == 'POST':\\n session.delete(categoryToDelete)\\n session.commit()\\n flash('%s Successfully Deleted' % categoryToDelete.name)\\n return redirect(url_for('showCatalog'))\\n else:\\n return render_template('deletecategory.html',\\n category=categoryToDelete)\",\n \"def destroy(self, request, *args, **kwargs):\\n response = super(CategoryViewSet, self).destroy(request, *args, **kwargs)\\n response.data = {'message': 'Categoria ha sido eliminada'}\\n return response\",\n \"def deleteCategory(category_id):\\n\\n if 'username' not in login_session:\\n return redirect('/login')\\n\\n categoryToDelete = session.query(Category).filter_by(id=category_id).one()\\n if categoryToDelete.user_id != login_session['user_id']:\\n flash('You are not the creator of %s category, and cannot modify it' %\\n categoryToDelete.name)\\n return redirect(url_for('showCategories'))\\n else:\\n if request.method == 'POST':\\n if \\\"btn_delete\\\" in request.form:\\n session.delete(categoryToDelete)\\n flash('%s Successfully Deleted' % categoryToDelete.name)\\n session.commit()\\n return redirect(url_for('showCategories'))\\n else:\\n return redirect(url_for('showCategories'))\\n else:\\n return render_template('deleteCategory.html',\\n category=categoryToDelete,\\n user=getUserInfo(login_session['user_id']))\",\n \"def test_delete(self, init_db, category):\\n category.delete()\\n assert Category.get(category.id) == None\",\n \"def deleteCategory(request, category_id):\\n try:\\n category = Category.objects.get(id=category_id)\\n print(\\\"id\\\", category)\\n except Category.DoesNotExist:\\n return Response({'message': \\\"requested category does not exist\\\", \\\"status\\\": status.HTTP_404_NOT_FOUND})\\n\\n if request.method == \\\"GET\\\":\\n serializer = CategorySerializer(category)\\n return Response({\\\"data\\\": serializer.data, \\\"status\\\": status.HTTP_200_OK})\\n\\n elif request.method == \\\"DELETE\\\":\\n category.delete()\\n return Response({\\\"message\\\": \\\"Catagory deleted successfully\\\", \\\"status\\\": status.HTTP_200_OK})\",\n \"def test_delete_category(self):\\n rv = self.client().post(\\n '/categories/',\\n data={'category_name': 'Sauces'})\\n self.assertEqual(rv.status_code, 201)\\n res = self.client().delete('/categories/1')\\n #self.assertEqual(res.status_code, 200)\\n # Test to see if it exists, should return a 404\\n result = self.client().get('/categories/1')\\n #self.assertEqual(result.status_code, 404)\",\n \"async def remove(self, ctx, cat: str, *, item: str):\\n c = check_category(cat)\\n if not c[0]:\\n await ctx.send(\\\"`{}` isn't a category you can add things to.\\\".format(cat))\\n return\\n else:\\n data = c[1]\\n datafile = c[2]\\n cat = c[3]\\n \\n user = ctx.author.name + \\\"#\\\" + ctx.author.discriminator\\n if user not in data:\\n await ctx.send(\\\"You haven't added anything to your {} list.\\\".format(cat))\\n else:\\n things = [x.strip() for x in item.split(',')]\\n success = \\\"\\\"\\n failure = \\\"\\\"\\n for thing in things:\\n try:\\n data[user].remove(thing.title())\\n success += \\\"`{}` was removed from your {} list.\\\\n\\\".format(thing.title(), cat)\\n except:\\n failure += \\\"You don't have a `{}` in your {} list.\\\\n\\\".format(thing.title(), cat)\\n try:\\n await ctx.send(success)\\n except:\\n pass\\n try:\\n await ctx.send(failure)\\n except:\\n pass\\n pickle.dump(data, open(datafile, \\\"wb\\\"))\",\n \"def delete(self, id):\\n category = Categories.query.get(id)\\n admin = get_jwt_claims()\\n if category is None:\\n return {'status': 'Not Found'}, 404, {'Content_Type': 'application/json'}\\n\\n db.session.delete(category)\\n db.session.commit()\\n return {\\\"Status\\\": \\\"The data with id {} is deleted\\\".format(id)}, 200, {'Content_Type': 'application/json'}\",\n \"async def delete_category(self, category):\\n stmt = delete(self.model)\\n\\n if self.category_field:\\n stmt = stmt.where(getattr(self.model, self.category_field) == category)\\n\\n self.session.execute(stmt)\",\n \"def destroy(self, request, pk=None):\\n\\n if not request.auth.user.is_staff:\\n return Response(\\n {'message': 'You must be an admin to delete categories.'},\\n status=status.HTTP_403_FORBIDDEN\\n )\\n\\n try:\\n category = Categories.objects.get(pk=pk)\\n\\n except Categories.DoesNotExist:\\n return Response(\\n {'message': 'There is no category with the specified ID.'},\\n status=status.HTTP_404_NOT_FOUND\\n )\\n\\n if category.label == 'Uncategorized':\\n return Response(\\n {'message': 'Deleting the `Uncategorized` category is forbidden.'},\\n status=status.HTTP_403_FORBIDDEN\\n )\\n\\n category.delete()\\n return Response({}, status=status.HTTP_204_NO_CONTENT)\",\n \"def test_delete_category(self):\\n self.add_success(self.test_data['pants'])\\n self.delete_success('pants')\",\n \"def test_category_delete(category):\\n category.delete()\\n\\n category = Category.query.filter_by(id=category.id).first()\\n\\n assert category is None\",\n \"def delete_category(self, category_id, user_id):\\r\\n category = self._db_manager.get_category(category_id)\\r\\n if category is None:\\r\\n flash(\\\"Invalid category.\\\")\\r\\n return\\r\\n if category[\\\"user_id\\\"] != user_id:\\r\\n flash(\\\"Only the original creator can delete a category.\\\")\\r\\n return\\r\\n flash(self._db_manager.delete_category(category_id))\",\n \"def delete(self):\\r\\n self.domain.delete_item(self)\",\n \"def delete_item(request):\\n if request.json_body[u'type'] == u'post':\\n if DBSession.query(Post).filter(Post.name==request.json_body[u'name']).delete() == 1:\\n return {\\\"deletion_status\\\":\\\"success\\\"}\\n import ipdb; impdb.set_trace()\\n return {\\\"deletion_status\\\":\\\"error\\\"}\",\n \"async def delete_recipe_category(category: str, session: Session = Depends(generate_session)):\\n\\n try:\\n db.categories.delete(session, category)\\n except Exception:\\n raise HTTPException(status.HTTP_400_BAD_REQUEST)\",\n \"def delete_category(category_id):\\n if request.args.get('state') != login_session['state']:\\n response = make_response(\\n json.dumps({'error': 'Invalid state parameter.'}), 401\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n if 'username' not in login_session:\\n response = make_response(\\n json.dumps({'error': 'User is logged out. This should not happen'}), 401\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n try:\\n if request.method == 'DELETE':\\n category = session.query(Category).filter_by(id=category_id).one()\\n session.delete(category)\\n session.commit()\\n state = get_new_state()\\n login_session['state'] = state\\n response = make_response(\\n json.dumps({'success': '', 'nonce': login_session['state']}), 200\\n )\\n response.headers['Content-Type'] = 'application/json'\\n return response\\n except Exception as inst:\\n print(type(inst))\\n print(inst.args)\\n print(inst)\",\n \"def test_category_delete(self):\\n login = self.autheniticate()\\n token = json.loads(login.data.decode()).get('token')\\n self.app.post(category_url,\\n data=json.dumps(self.data),\\n headers=dict(Authorization=\\\"Bearer \\\" + token),\\n content_type='application/json')\\n res = self.app.delete('/api/v2/categories/1',\\n headers=dict(Authorization=\\\"Bearer \\\" + token),\\n content_type='application/json')\\n res1 = json.loads(res.data.decode())\\n self.assertEqual(res1['status'], 'Deleted!')\\n self.assertEqual(res.status_code, 200)\",\n \"def delete_recipe_category(db_id):\\r\\n\\r\\n # determines the category name by id\\r\\n category_name = mongo.db.recipe_categories.find_one(\\r\\n {'_id': ObjectId(db_id)})['name']\\r\\n\\r\\n # removes all the recipes in the category\\r\\n mongo.db.recipes.remove({'category': category_name})\\r\\n\\r\\n # removes the recipe category\\r\\n mongo.db.recipe_categories.remove({'_id': ObjectId(db_id)})\\r\\n\\r\\n # redirects to the recipe category search\\r\\n return redirect(url_for(\\r\\n 'search',\\r\\n collection='recipe_categories')\\r\\n )\",\n \"def _delete(self, item):\\n self.cv.delete(item)\",\n \"def delete(current_user, self, category_id, recipe_id):\\n if not current_user:\\n return is_unauthorized()\\n\\n category = current_user.categories.filter_by(id=category_id).first()\\n if category:\\n selected_recipe = category.recipes.filter_by(id=recipe_id).first()\\n # When the recipe requested does not exist\\n if not selected_recipe:\\n return _does_not_exist()\\n name = selected_recipe.name\\n # Delete the selected recipe\\n db.session.delete(selected_recipe)\\n db.session.commit()\\n # Render response\\n response_payload = {\\n \\\"message\\\": \\\"Recipe \\\" + name + \\\" was deleted successfully!\\\"\\n }\\n response_payload = jsonify(response_payload)\\n return make_response(response_payload, 200)\\n # When an invalid category id is provided\\n response_payload = dict(\\n message='Category does not exist!'\\n )\\n response_payload = jsonify(response_payload)\\n return make_response(response_payload, 404)\",\n \"def render_delete_category_page(\\r\\n self, client_id, state, user_id, user_name, category_id):\\r\\n category = self._db_manager.get_category(category_id)\\r\\n if category is None:\\r\\n flash(\\\"Invalid category.\\\")\\r\\n return\\r\\n if category[\\\"user_id\\\"] != user_id:\\r\\n flash(\\\"Only the original creator can delete a category.\\\")\\r\\n return\\r\\n return render_template(\\r\\n \\\"category_delete.html\\\",\\r\\n client_id=client_id,\\r\\n state=state,\\r\\n is_logged_in=True,\\r\\n user_name=user_name,\\r\\n category=category\\r\\n )\",\n \"def destroy(self, request, pk=None):\\n current_user = User.objects.get(id=request.user.id)\\n if current_user.is_staff:\\n try:\\n category = Category.objects.get(pk=pk)\\n category.delete()\\n return Response({}, status=status.HTTP_204_NO_CONTENT)\\n except Category.DoesNotExist:\\n return Response({\\\"reason\\\": \\\"Doesn't Exist\\\"}, status=status.HTTP_400_BAD_REQUEST)\\n else:\\n return Response({'message': 'Stop, seriously, just stop. You are not an admin'},\\n status=status.HTTP_403_FORBIDDEN)\",\n \"def delete_item(request, product_id):\\n\\n if not request.user.is_superuser:\\n messages.error(request, 'Sorry, you are not permitted to do that.')\\n return redirect(reverse('home'))\\n\\n product = get_object_or_404(Product, pk=product_id)\\n product.delete()\\n messages.success(request, 'You have deleted the item!')\\n return redirect(reverse('items'))\",\n \"def remove_item(item_id):\\n remove_item = session.query(Item).filter_by(id=item_id).one()\\n category_id = remove_item.category_id\\n\\n # redirect to details page if current user does not own item\\n if remove_item.user_id != login_session['user_id']:\\n return redirect(\\n url_for(\\n 'item_details',\\n category_id=category_id,\\n item_id=remove_item.id))\\n\\n if request.method == 'POST':\\n session.delete(remove_item)\\n session.commit()\\n return redirect(\\n url_for(\\n 'items_for_category', category_id=category_id))\\n else:\\n return render_template(\\n 'views/delete.html',\\n item_to_delete=remove_item,\\n category_id=category_id)\",\n \"def delete_item(self):\\n\\n\\t\\tdb.session.delete(self)\\n\\t\\tdb.session.commit()\",\n \"def excluir_categoria():\\n try:\\n if current_user.is_administrator():\\n cod_id = request.args.get('id')\\n categoria = Categoria.query.filter_by(cod_categoria = cod_id).one()\\n db.session.delete(categoria)\\n db.session.commit()\\n return listar_questoes()\\n return redirect(url_for('admin.listar_questoes'))\\n except Exception as e:\\n abort(500, e)\",\n \"def delete_item(request, shoppinglist_id, item_id):\\n Item.objects.filter(pk=item_id,\\n shoppinglist__pantry__owner=request.user).delete()\\n return redirect('shoppinglists.views.detail', shoppinglist_id)\",\n \"def delete_item(item_id):\\n\\n item = Item.query.filter(\\n Item.id == item_id,\\n Item.user_id == current_user.id\\n ).first()\\n\\n if not item:\\n flash(\\\"Couldn't find the item\\\", category='warning')\\n return redirect(request.referrer)\\n\\n item_name = item.name\\n db.session.delete(item)\\n db.session.commit()\\n flash(\\n \\\"Successfully deleted item '{}'\\\".format(item_name),\\n \\\"success\\\")\\n\\n return redirect(url_for('url.index'))\",\n \"def delete_item(item_name):\\n\\n item = Item.query.filter_by(name=item_name).first_or_404()\\n if item.owner != current_user:\\n flash(\\\"Failed to delete item %s since you are not the owner.\\\" %\\n item.name)\\n return redirect(url_for('.index'))\\n\\n form = DeleteForm()\\n if form.validate_on_submit():\\n try:\\n db.session.delete(item)\\n db.session.commit()\\n except:\\n flash((\\\"Failed to delete item \\\\\\\"%s\\\\\\\".\\\") % item.name)\\n else:\\n flash(\\\"Item \\\\\\\"%s\\\\\\\" has been deleted.\\\" % item.name)\\n finally:\\n return redirect(url_for('.index'))\\n return render_template('delete.html', form=form, name=item_name)\",\n \"def delete(self, something):\\n if something == Concept:\\n number = 0\\n target_list = self.concept_list\\n elif something == Subcategory:\\n number = 1\\n target_list = self.concept_list\\n elif something == Relation:\\n number = 2\\n target_list = self.relation_list\\n if target_list.currentIndex().isValid():\\n something = target_list.selectedItems()[0].data(Qt.UserRole)[number]\\n self.db.delete(something)\\n self.search()\",\n \"def delete_item(item_name):\\n item = Item.query.filter_by(name=item_name).first()\\n\\n # If the URL contains a bad item name, send a 404\\n if not item:\\n abort(404)\\n\\n # If the current user is not authorized to delete the item because\\n # the item was created by a different user, send a 403\\n elif current_user != item.user:\\n abort(403)\\n\\n form = DeleteItemForm()\\n\\n # If the form is submitted, delete the item from the database,\\n # send a flash message, and redirect home\\n if form.validate_on_submit():\\n db.session.delete(item)\\n db.session.commit()\\n flash(f'\\\"{item.name}\\\" has been deleted.', 'good')\\n return redirect(url_for('main.home'))\\n\\n return render_template('delete_item.html', item=item, form=form)\",\n \"def test_delete_recipe_category(self):\\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\\n self.login('Bo_theo5@example.com', 'Bo1995')\\n self.dashboard()\\n self.category('JunkFood')\\n self.dashboard()\\n self.recipe_dashboard()\\n self.create_recipe('cakes', 'blah, blah, blah....mix ingredient, heat')\\n self.edit_recipe('edited cakes', 'edited blah blah blah spoon , heat')\\n rv = self.del_recipe()\\n self.assertIn(b'deleted successfully', rv.data)\",\n \"def do_del_item(self, arg):\\n try:\\n del_item = arg[\\\"<list_name>\\\"]\\n choice = arg[\\\"--choice\\\"]\\n if choice == \\\"name\\\":\\n del_item_str = \\\" \\\".join(del_item)\\n print(del_item_str)\\n elif choice == \\\"id\\\":\\n del_item_str = int(\\\" \\\".join(del_item))\\n print (del_item_str)\\n app.ToDoApp.to_delete_item(del_item_str)\\n print (\\\"Item deleted\\\")\\n\\n\\n \\n except ValueError as e:\\n cprint((e), 'red')\",\n \"def delete_item(self, id: str, user: User) -> bool:\",\n \"def deleteCategory(category_id):\\r\\n # authentication\\r\\n if 'username' not in login_session:\\r\\n flash('Please login to edit category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n # validation\\r\\n deletedCategory = session.query(Category).filter_by(id=category_id).first()\\r\\n if not deletedCategory:\\r\\n flash('Attempt to delete non-existent category')\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n # authorization\\r\\n if login_session['user_id'] != deletedCategory.user_id:\\r\\n flash('Sorry, you are not authorized to delete the category \\\\'{}\\\\''\\r\\n .format(deletedCategory.name))\\r\\n return redirect(url_for('showCategories'))\\r\\n\\r\\n # delete operation\\r\\n if request.method == 'POST':\\r\\n session.delete(deletedCategory)\\r\\n session.commit()\\r\\n flash('Deleted Category \\\\'{}\\\\' Successfully'.format(\\r\\n deletedCategory.name))\\r\\n return redirect(url_for('showCategories'))\\r\\n else:\\r\\n # serve GET requests with confirmation form\\r\\n return render_template(\\\"deleteCategory.html\\\", category=deletedCategory)\",\n \"def test_delete_category_does_not_exist(self):\\n self.delete_does_not_exist_fail('hats')\",\n \"def delete(self):\\n response = settings.database.delete_item(Key={'id': str(self.id)})\\n raise_for_response(response)\",\n \"def delete(item_id):\\n session = current_app.config['db']\\n if request.method == \\\"POST\\\":\\n used = session.query(func.count(WineType.id).label('count'))\\\\\\n .filter_by(abv_id=item_id).scalar()\\n item = session.query(WineABV).filter_by(id=item_id).one()\\n c_name = item.name\\n if used == 0:\\n session.delete(item)\\n session.commit()\\n flash(\\\"Successfully Deleted '%s'\\\" % (c_name,), 'success')\\n else:\\n flash(\\\"'%s' is still in use and cannot be deleted.\\\" % (c_name,),\\n 'danger')\\n return redirect(url_for('.show'))\\n\\n else:\\n item = session.query(WineABV).filter_by(id=item_id).one()\\n return render_template(template_prefix+'delete_form.html', item=item)\",\n \"def cfDel(self, key, item):\\n params = [key, item]\\n\\n return self.execute_command(self.CF_DEL, *params)\",\n \"def delete_one(id):\\r\\n # Get the category requested\\r\\n category = Category.query.filter(Category.id == id).one_or_none()\\r\\n\\r\\n if category is not None:\\r\\n sqlalc.session.delete(category)\\r\\n sqlalc.session.commit()\\r\\n return make_response(f\\\"The category {id} is deleted\\\", 200)\\r\\n\\r\\n else:\\r\\n abort(404, f\\\"Category not found for id: {id}\\\")\",\n \"async def delete_category(self, category):\\n await super(MemoryKVCache, self).delete_category(category)\\n\\n if self.in_transaction:\\n self.dirty_categories.add(category)\",\n \"def delete_item(id):\\n return '', 201\",\n \"def deleteItem(request, itemid):\\n try:\\n item = ItemSerializer(Item.objects.get(id=itemid))\\n Item.objects.get(id=itemid).delete()\\n return Response(item.data)\\n\\n except Item.DoesNotExist:\\n fail = {\\n \\\"item\\\":\\\"item does not exist\\\"\\n }\\n return JsonResponse(fail)\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def remove_item_page(request):\\n validate(instance=request.body, schema=item_schema_remove)\\n body = json.loads(request.body)\\n Item.remove_item(body['item_id'])\\n return HttpResponse('success')\",\n \"def delete(self, id_):\\n \\n db.categories.remove({'_id': ObjectId(id_)})\\n return '', 204\",\n \"def test_delete_single_recipe_category(self):\\n with self.client:\\n response = self.register_user(\\n \\\"Patrick\\\", \\\"Walukagga\\\", \\n \\\"pwalukagga@gmail.com\\\", \\\"telnetcmd123\\\"\\n )\\n # registered user login\\n rep_login = self.login_user(\\\"pwalukagga@gmail.com\\\", \\\"telnetcmd123\\\")\\n # valid token\\n headers=dict(\\n Authorization='Bearer ' + json.loads(\\n rep_login.data.decode()\\n )['auth_token']\\n )\\n cresponse = self.create_category(\\\"Breakfast\\\", \\n \\\"How to make breakfast\\\", \\n headers)\\n \\n response = self.create_category(\\\"Lunchfast\\\", \\n \\\"How to make lunchfast\\\", \\n headers)\\n response = self.client.delete('/recipe_category/1', \\n headers=headers)\\n self.assertEqual(response.status_code, 200)\\n self.assertIn('Recipe category deleted', \\n str(response.data))\\n # delete recipe category not in database\\n response = self.client.delete('/recipe_category/3', \\n headers=headers, )\\n self.assertEqual(response.status_code, 404)\\n self.assertIn('No category found', \\n str(response.data))\",\n \"async def delete_category(self, category: str) -> dict:\\n async with self.lock:\\n await self.storage.delete_category(category)\\n return await self.cache.delete_category(category)\",\n \"def delete(self, item, request):\\n\\n assert (\\n isinstance(item, Election)\\n or isinstance(item, ElectionCompound)\\n or isinstance(item, Vote)\\n )\\n\\n url = request.link(item)\\n url = replace_url(url, request.app.principal.official_host)\\n for result in self.query().filter_by(url=url):\\n self.session.delete(result)\\n\\n self.session.delete(item)\\n self.session.flush()\",\n \"def test_delete_item_using_delete(self):\\n pass\",\n \"def render_delete_item_page(\\r\\n self, client_id, state, user_id, user_name, item_id):\\r\\n item = self._db_manager.get_item(item_id)\\r\\n if item is None:\\r\\n flash(\\\"Invalid item.\\\")\\r\\n return\\r\\n if item[\\\"user_id\\\"] != user_id:\\r\\n flash(\\\"Only the original creator can delete an item.\\\")\\r\\n return\\r\\n category = self._db_manager.get_category(item[\\\"category_id\\\"])\\r\\n if category is None:\\r\\n flash(\\\"Sorry, something went wrong.\\\")\\r\\n return\\r\\n return render_template(\\r\\n \\\"item_delete.html\\\",\\r\\n client_id=client_id,\\r\\n state=state,\\r\\n is_logged_in=True,\\r\\n user_name=user_name,\\r\\n category=category[\\\"name\\\"],\\r\\n item=item\\r\\n )\",\n \"def item_delete(request):\\n if request.method == 'POST':\\n item_to_delete = get_object_or_404(StockItem, pk=request.POST['id'])\\n item_to_delete.active = False\\n item_to_delete.save()\\n return HttpResponse(status=200)\",\n \"def delete(self):\\n return self.items.delete(item_id=self.id)\",\n \"def deleteItem(sport_id, item_id):\\n\\n sport = session.query(Sport).filter_by(id=sport_id).one()\\n deletedItem = session.query(Item).filter_by(id=item_id).one()\\n if request.method == 'POST':\\n session.delete(deletedItem)\\n session.commit()\\n return redirect(url_for('showSports'))\\n else:\\n return render_template('deleteitem.html', sport_id=sport_id,\\n item_id=item_id, sport=sport, item=deletedItem)\",\n \"def delete(request, itemID):\\n\\ttry:\\n\\t\\titem = get_object_or_404(Item, itemID = itemID)\\n\\n\\t# Handle when the given itemID is not a UUID\\n\\texcept ValidationError:\\n\\t\\traise Http404\\n\\n\\tif item.seller.user != request.user:\\n\\t\\traise Http404\\n\\t\\n\\titem.delete()\\n\\treturn HttpResponseRedirect(reverse('tailored:index'))\",\n \"def delete_recipe(db_id):\\r\\n\\r\\n # keeps recipe category link\\r\\n category = mongo.db.recipes.find_one(\\r\\n {'_id': ObjectId(db_id)})['category']\\r\\n\\r\\n # removes recipe\\r\\n mongo.db.recipes.remove({'_id': ObjectId(db_id)})\\r\\n\\r\\n # updates counter in the category\\r\\n update_quantity_in_category(category)\\r\\n\\r\\n # redirects to the recipes in the same category\\r\\n return redirect(url_for(\\r\\n 'search',\\r\\n collection='recipes',\\r\\n find=category)\\r\\n )\",\n \"def post_delete(self, *args, **kw):\\n #obtenemos el id de la fase para hacer el filtrado despues de la redireccion\\n item_to_del = DBSession.query(Item).filter_by(id_item=args[0]).one()\\n fid = item_to_del.id_fase_fk\\n pks = self.provider.get_primary_fields(self.model)\\n d = {}\\n for i, arg in enumerate(args):\\n d[pks[i]] = arg\\n self.provider.delete(self.model, d)\\n\\n path = './' + '../' * (len(pks) - 1) + '?fid=' + str(fid)\\n\\n redirect(path)\",\n \"def post_delete(self, *args, **kw):\\n id_atributo = int(args[0])\\n transaction.begin()\\n attr = AtributosPorTipoItem.por_id(id_atributo)\\n DBSession.delete(attr)\\n transaction.commit()\\n flash(\\\"Atributo Eliminado\\\")\\n redirect(\\\"./\\\")\",\n \"def delete_item_details(item_id):\\n item = is_user_the_creator(item_id)\\n item_name = item.Item.name\\n if request.method == 'GET':\\n return render_template('item_delete_confirm.html', item_name=item_name, item_id=item_id,\\n login_session=login_session,\\n csrf_token=generate_csrf_token())\\n else:\\n session.delete(item.Item)\\n session.commit()\\n flash(item_name + \\\" deleted\\\")\\n return redirect(url_for('show_homepage'))\",\n \"def on_delete(action, item, view):\\n actors.remove(action.actor)\\n self.remove(item)\",\n \"def delete_item(self):\\n self.df_user.drop(self.index_select_number, inplace=True)\\n self.df_user.to_csv(\\\"user_items.csv\\\", index=False)\\n self.update_treeview()\\n self.changing_item_label.config(text=\\\"Please double click on the item you want to edit.\\\")\\n self.delete_but.destroy()\\n self.serv_drop.destroy()\\n self.serv_but.destroy()\\n self.pop_up_del.destroy()\",\n \"def delete(self):\\n ...\",\n \"def delete_item_wishlist():\\n curItem = wishlist_treeview.focus().strip('#')\\n\\n with open(\\\"Other_title_categories.json\\\", \\\"r\\\") as other_categories_fo:\\n other_categories_foData = json.load(other_categories_fo)\\n completeDict = other_categories_foData[\\\"wish_list\\\"]\\n selectetItemData_complete = completeDict[curItem]\\n\\n print(\\\"deleting : \\\", curItem)\\n\\n del completeDict[curItem]\\n other_categories_foData[\\\"wish_list\\\"] = completeDict\\n\\n with open('Other_title_categories.json', 'w') as f:\\n json.dump(other_categories_foData, f, indent=2)\\n print(\\\"done deleting the title \\\", curItem)\\n\\n wishlist_treeview.delete(wishlist_treeview.focus())\",\n \"def delete_entry():\\n if not check_admin_logged() :\\n abort(403)\\n\\n title = request.args.get('title', default='')\\n category = request.args.get('category', default='')\\n buydate = request.args.get('buydate', default='')\\n ssid = decrypt_book_record(request.args.get('ssid'))\\n\\n pre_delete_entry = Entries.query.filter_by(\\n id=ssid, title=title, category=category, \\\\\\n buydate=buydate).first()\\n\\n if pre_delete_entry is not None :\\n try :\\n db.session.delete(pre_delete_entry)\\n db.session.commit()\\n flash(u'删除成功')\\n except InvalidRequestError as e :\\n log_error('error when delete:')\\n log_error(e.message)\\n #log_error(u'when delete item %s ' % str(pre_delete_entry))\\n # DO NOT use the above one for the F UnicodeEncodeError\\n log_error(u'when delete item %s ' % pre_delete_entry)\\n db.session.flush()\\n flash(u'因为数据库操作原因，删除失败')\\n else :\\n flash(u'删除失败')\\n\\n return redirect(url_for('show_entries_admin'))\",\n \"def delete():\\n id_num = int(input('Enter the ID number of the item you wish to delete\\\\n'))\\n db_actions.remove(id_num)\",\n \"def del_category(self, category):\\n if category in self.categories:\\n self.categories.remove(category)\",\n \"def test_delete_a_category_invalid_token(self):\\n self.test_add_category_success()\\n token = \\\"\\\"\\n response = self.client.delete('/categories/1',\\n headers={\\\"Authorization\\\": token})\\n self.assertEqual(response.status_code, 401)\\n self.assertIn('Token not found', response.data.decode())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8067774","0.8005237","0.7868571","0.78579575","0.7821217","0.77969927","0.7698097","0.7654832","0.7649916","0.76128393","0.75621045","0.7551869","0.74583393","0.74365985","0.73939204","0.73760337","0.734237","0.726488","0.7225764","0.72094333","0.71772903","0.71766996","0.71602726","0.7127478","0.71256256","0.71035093","0.70699614","0.7047942","0.70065194","0.69924694","0.69804436","0.69741464","0.69703627","0.6968446","0.69311196","0.6927521","0.6910141","0.6906975","0.68872464","0.6882915","0.6839683","0.6828008","0.68244976","0.6819401","0.6809556","0.67681164","0.6745121","0.6742868","0.6725092","0.6692932","0.665464","0.66377187","0.662174","0.66184306","0.66017234","0.6594964","0.658643","0.65769994","0.65495145","0.6547699","0.6545169","0.653838","0.6530414","0.6492891","0.6483491","0.6474269","0.6471402","0.6457623","0.6442548","0.64328676","0.64253885","0.6417726","0.6410431","0.64053667","0.640011","0.63979125","0.63979125","0.63974756","0.6394927","0.6384956","0.6379144","0.637636","0.63722175","0.6367453","0.6351088","0.6347398","0.6342271","0.6323667","0.6309901","0.6296844","0.6282065","0.62702894","0.62468886","0.62412375","0.624057","0.6227737","0.6222058","0.62197584","0.6175818","0.6169895"],"string":"[\n \"0.8067774\",\n \"0.8005237\",\n \"0.7868571\",\n \"0.78579575\",\n \"0.7821217\",\n \"0.77969927\",\n \"0.7698097\",\n \"0.7654832\",\n \"0.7649916\",\n \"0.76128393\",\n \"0.75621045\",\n \"0.7551869\",\n \"0.74583393\",\n \"0.74365985\",\n \"0.73939204\",\n \"0.73760337\",\n \"0.734237\",\n \"0.726488\",\n \"0.7225764\",\n \"0.72094333\",\n \"0.71772903\",\n \"0.71766996\",\n \"0.71602726\",\n \"0.7127478\",\n \"0.71256256\",\n \"0.71035093\",\n \"0.70699614\",\n \"0.7047942\",\n \"0.70065194\",\n \"0.69924694\",\n \"0.69804436\",\n \"0.69741464\",\n \"0.69703627\",\n \"0.6968446\",\n \"0.69311196\",\n \"0.6927521\",\n \"0.6910141\",\n \"0.6906975\",\n \"0.68872464\",\n \"0.6882915\",\n \"0.6839683\",\n \"0.6828008\",\n \"0.68244976\",\n \"0.6819401\",\n \"0.6809556\",\n \"0.67681164\",\n \"0.6745121\",\n \"0.6742868\",\n \"0.6725092\",\n \"0.6692932\",\n \"0.665464\",\n \"0.66377187\",\n \"0.662174\",\n \"0.66184306\",\n \"0.66017234\",\n \"0.6594964\",\n \"0.658643\",\n \"0.65769994\",\n \"0.65495145\",\n \"0.6547699\",\n \"0.6545169\",\n \"0.653838\",\n \"0.6530414\",\n \"0.6492891\",\n \"0.6483491\",\n \"0.6474269\",\n \"0.6471402\",\n \"0.6457623\",\n \"0.6442548\",\n \"0.64328676\",\n \"0.64253885\",\n \"0.6417726\",\n \"0.6410431\",\n \"0.64053667\",\n \"0.640011\",\n \"0.63979125\",\n \"0.63979125\",\n \"0.63974756\",\n \"0.6394927\",\n \"0.6384956\",\n \"0.6379144\",\n \"0.637636\",\n \"0.63722175\",\n \"0.6367453\",\n \"0.6351088\",\n \"0.6347398\",\n \"0.6342271\",\n \"0.6323667\",\n \"0.6309901\",\n \"0.6296844\",\n \"0.6282065\",\n \"0.62702894\",\n \"0.62468886\",\n \"0.62412375\",\n \"0.624057\",\n \"0.6227737\",\n \"0.6222058\",\n \"0.62197584\",\n \"0.6175818\",\n \"0.6169895\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80150735"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14891,"cells":{"query":{"kind":"string","value":"Returns JSON of all items in catalog"},"document":{"kind":"string","value":"def showItemsJSON():\n items = db.getAllItems()\n return jsonify(CategoryItems=[i.serialize for i in items])"},"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 catalog_json():\n all_categories = (session.query(Categories).all())\n all_items = (session.query(Items).all())\n return jsonify(categories=([all_categories.serialize\n for all_categories in all_categories]),\n items=([all_items.serialize\n for all_items in all_items]))","def catalog_json():\n catalog_json = []\n try:\n all_categories = session.query(Category).all()\n for category in all_categories:\n items_for_category = session.query(\n Item).filter_by(\n category_id=category.id).all()\n items = []\n for current_item in items_for_category:\n items.append(current_item.serialize)\n catalog_json.append({\n 'category_name': category.name,\n 'category_id': category.id,\n 'items': items\n })\n except Exception as e:\n error = {\n 'result': 'No catalog data: ' + str(e)\n }\n catalog_json.append(error)\n return jsonify(catalog_json)","def get_jsonified_catalogs():\n\n json = []\n catalogs = session.query(Catalog).all()\n\n for catalog in catalogs:\n catalog_json = {}\n catalog_json[\"id\"] = catalog.id\n catalog_json[\"name\"] = catalog.name\n catalog_json[\"date\"] = catalog.date.strftime(\"%d %b %Y %H: %M: %S\")\n catalog_json[\"items\"] = []\n for item in catalog.items:\n item_json = {}\n item_json[\"id\"] = item.id\n item_json[\"title\"] = item.title\n item_json[\"desc\"] = item.desc\n item_json[\"date\"] = item.date.strftime(\"%d %b %Y %H: %M: %S\")\n item_json[\"catalog_id\"] = item.catalog_id\n catalog_json[\"items\"].append(item_json)\n json.append(catalog_json)\n return jsonify(Catalogs=json)","def rest_get_catalogue_handler():\n cats = category.get_all_categories()\n items = item.get_all_items()\n result = {}\n result['categories'] = [c.serialize for c in cats]\n result['items'] = [i.serialize for i in items]\n return jsonify(result)","def get_catalog():\n return jsonify(getCatalog())","def all_items_handler():\n items = getAllItems()\n return jsonify(items=[i.serialize for i in items])","def itemCatalogJSON(sport_id):\n\n sport = session.query(Sport).filter_by(id=sport_id).one()\n items = session.query(Item).filter_by(\n sport_id=sport_id).all()\n return jsonify(Sport=[i.serialize for i in items])","def getItemsJSON(category_id):\r\n items = session.query(Item).filter_by(category_id=category_id).all()\r\n return jsonify(Items=[i.serialize for i in items])","def showCategoryItemsJSON(category_id):\r\n session = DBSession()\r\n items = session.query(Item).filter_by(category_id=category_id)\r\n return jsonify(Items=[i.serialize for i in items])","def api_all():\r\n\tconn = sqlite3.connect('Shopify_products.db')\r\n\tconn.row_factory = dict_factory\r\n\tcur = conn.cursor()\r\n\tall_products = cur.execute('SELECT * FROM products WHERE inventory_count>0;').fetchall()\r\n\treturn jsonify(all_products)","def catalogItemJSON(sport_id, item_id):\n\n catalogItem = session.query(Item).filter_by(id=item_id).one()\n return jsonify(Item=catalogItem.serialize)","def catelogJSON():\n categories = session.query(Category).all()\n items = session.query(Item).all()\n catelog = []\n for i in categories:\n li = []\n for j in items:\n if j.category_id == i.id:\n temp = j.serialize\n li += [temp]\n temp = i.serialize\n if len(li) > 0:\n temp['Items'] = li\n catelog += [temp]\n\n return jsonify(Categories=catelog)","def get_items_for_catalog(catalog_id):\n pass","def allCategoriesJSON():\n categories = db_session.query(Category).all()\n return jsonify(categories=[c.serialize for c in categories])","def all_categories_handler():\n categories = getAllCategories()\n return jsonify(categories=[i.serialize for i in categories])","def json(self):\n return {\"name\": self.name,\n \"items\": [item.json() for item in self.item]} # self.name==storeObj.name and self.item==storeObj.item","def categoryItemJSON(category_id):\n category = db.getByCategory(category_id)\n items = db.getItemsByCategory(category_id)\n return jsonify(Items=[i.serialize for i in items])","def get_catalog_items(id):\n\n username = login_session.get('username', None)\n catalogs = session.query(Catalog).all()\n selected_catalog = session.query(Catalog).filter_by(id=id).one()\n items = selected_catalog.items\n catalogs_display = [\n {\n 'id': catalog.id,\n 'name': catalog.name\n } for catalog in catalogs]\n items_display = [{'id': item.id, 'title': item.title} for item in items]\n items_summary = '{0} Items ({1} items)'.format(\n selected_catalog.name,\n len(items_display))\n return render_template(\n 'home.html',\n catalogs_display=catalogs_display,\n items_display=items_display,\n items_summary=items_summary,\n username=username)","def getCatalogs():","def showCategoriesJSON():\r\n session = DBSession()\r\n categories = session.query(Category).all()\r\n return jsonify(Categories=[c.serialize for c in categories])","def categoryItemJSON(category_id):\n category = session.query(Category).\\\n filter_by(id=category_id).one()\n items = session.query(Item).\\\n filter_by(category_id=category_id).all()\n return jsonify(Items=[i.serialize for i in items])","def json_api():\n if 'category' in request.args:\n sqlsession = SQLSESSION()\n category = sqlsession.query(Category)\\\n .filter_by(name=request.args['category']).first()\n items = sqlsession.query(Item).filter_by(category_id=category.id)\\\n .all()\n return json.dumps({'category_id': category.id,\n 'category_name': category.name,\n 'items': [item.serialize() for item in items]})\n elif 'item' in request.args:\n sqlsession = SQLSESSION()\n items = sqlsession.query(Item).filter_by(name=request.args['item'])\\\n .all()\n return json.dumps([item.serialize() for item in items])\n sqlsession = SQLSESSION()\n categories = sqlsession.query(Category).all()\n items = sqlsession.query(Item).all()\n return json.dumps(\n {'categories': [cat.serialize() for cat in categories],\n 'items': [item.serialize() for item in items]})","def categoriesJSON():\n categories = session.query(Category).all()\n return jsonify(Categories=[r.serialize for r in categories])","def api_category_items(category_id):\n items = session.query(Item).filter(Item.category_id == category_id)\n return jsonify(json_list=[i.to_json() for i in items.all()])","def getCategoriesJSON():\r\n categories = session.query(Category).all()\r\n return jsonify(Categories=[c.serialize for c in categories])","def get_categories(request):\n return JsonResponse(get_all_objects(Category, CategorySerializer), safe=False)","def categoryItemsJSON(category_id):\n\n try:\n category = session.query(Category).filter_by(id=category_id).one()\n items = session.query(ListItem).filter_by(\n category_id=category_id).all()\n return jsonify(ListItems=[i.serialize for i in items])\n except Exception as e:\n return '''There was a problem with your query %s, please Verify,\n Redirecting to main page...\n <script> setTimeout(function() {\n window.location.href = \"/\";\n }, 2000);\n </script> ''' % (str(e))","def products():\n try:\n return jsonify(get_product_caching_service().jsonofied_product_map)\n except Exception as exception:\n return jsonify({'Something went wrong: ': exception})","def catalog():\n session['target'] = \"/\"\n sqlsession = SQLSESSION()\n items = sqlsession.query(Item, Category)\\\n .join(Category).order_by(Item.create_date).limit(10)\n categories = sqlsession.query(Category).all()\n return render_template(\"catalog.html\",\n items=items,\n categories=categories,\n item_title=\"Latest Items\")","def api_categories():\n categories = session.query(Category)\n return jsonify(json_list=[i.to_json() for i in categories.all()])","def show_item_json(category, item):\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n item = (session.query(Items)\n .filter_by(name=item.replace('-', ' '))\n .one())\n return jsonify(item=[item.serialize])","def get_categories():\n categories = [c.serialize for c in session.query(Category).all()]\n for c in range(len(categories)):\n items = [\n i.serialize for i in session.query(Item).filter_by(\n category_id=categories[c][\"id\"]).all()]\n if items:\n categories[c][\"Item\"] = items\n return jsonify(Category=categories)","def list(self, request):\n item_categories = ItemCategory.objects.all()\n\n serializer = ItemCategorySerializer(\n item_categories, many=True, context={'request': request})\n return Response(serializer.data)","def get_catalog(self):\n\n rep = req.get_json(self.CATALOG)\n repo_list = rep[\"repositories\"]\n\n for repo in repo_list:\n self.list.append(Repository(repo))\n\n return self.list","def itemJSON(category_id, item_id):\n item = session.query(Item).filter_by(id=item_id).one()\n return jsonify(Item=item.serialize)","def serialize_catalog(catalog, with_extra=False):\n data, acls, collabs = _recursve_catalog(catalog)\n if with_extra:\n return json.dumps(data), json.dumps(acls), json.dumps(collabs)\n else:\n return json.dumps(data)","def get_all_categories():\n return jsonify({\n \"success\": True,\n \"categories\": _read_all_categories()\n })","def api_display_cart():\r\n\tconn = sqlite3.connect('Shopify_products.db')\r\n\tconn.row_factory = dict_factory\r\n\tcur = conn.cursor()\r\n\tcart = cur.execute('SELECT * FROM cart;').fetchall()\r\n\tcart.append(cur.execute('SELECT SUM(price) from cart;').fetchone())\r\n\treturn jsonify(cart)","def query_items_handler(query):\n items = getItemsByName(query)\n return jsonify(items=[i.serialize for i in items])","def show_category_json(category):\n category = (session.query(Categories)\n .filter_by(name=category.replace('-', ' '))\n .one())\n category_items = (session.query(Items)\n .filter_by(category_id=category.id)\n .order_by(Items.name)\n .all())\n return jsonify(category=[category.serialize],\n items=([category_items.serialize\n for category_items in category_items]))","def products_with_inventory():\n try:\n return jsonify(get_product_caching_service().jsonified_map)\n except Exception as exception:\n return jsonify({'Something went wrong ': exception})","def get(cls):\n return {'products': [product.to_json() for product in ProductModel.find_all()]}","def amenity_get_all():\n am_list = []\n am_obj = storage.all(\"Amenity\")\n for obj in am_obj.values():\n am_list.append(obj.to_json())\n\n return jsonify(am_list)","def browse_categories(request):\n\n result = {}\n\n u = request.user\n\n top = Category.objects.get(name=\"Best Buy\")\n result['categories'] = [c.get_json() for c in top.children.all()]\n \n return JSONHttpResponse(result)","def list_catalogs(self):\n return self._json_object_field_to_list(\n self._get_catalogs_json(), self.__MISSION_STRING)","def showItemJSON(category_id, item_id):\r\n session = DBSession()\r\n item = session.query(Item).filter_by(id=item_id).one()\r\n return jsonify(Item=item.serialize)","def to_json(self):\n return {\n \"item_name\": self.item_name,\n \"summary\": self.summary,\n \"content\": self.content,\n \"date_published\": self.date_published,\n \"item_slug\": self.item_slug,\n \"category_name\": self.category_name,\n }","def get_items_by_cart_page(request):\n items = Item.get_items_by_cart(request.GET['cart_id'])\n items = models_to_json(items)\n return JsonResponse({'items': items})","def products(self):\n response = requests.get(self._url(self._PRODUCTS_PATH), headers=self._headers)\n return response.json()","def cat_results_react():\n\n cats = petfinder.search_data_map()\n cats = list(cats.values())\n\n return jsonify(cats)","def get(self):\n return GenericGet().get_catalogs()","def get_all_data():\n return jsonify(service.get_all_data())","def get_all(self) -> RestaurantCatalog:\n catalog = RestaurantCatalog()\n catalog.add_many(list(self.__data.values()))\n return catalog","def getall():\n elements = Advertisements().get_all_elements()\n data = jsonify(elements)\n data.statut_code = 200\n return data","def get_items():\n return requester.perform_request(Uri.items)","def collections():\n\tcollections = models.Collection.query.all()\n\tif not collections:\n\t\tabort(404)\n\tresponse = { 'collections': [c.dictionary() for c in collections] }\n\treturn jsonify(response)","def categories_json():\n try:\n categories = session.query(Category).all()\n return jsonify(categories=[category.serialize for category in categories])\n except Exception as inst:\n print(type(inst))\n print(inst.args)\n print(inst)","def get_categories():\n try:\n result = {\n \"success\": True,\n \"categories\": get_all_categories()\n }\n return jsonify(result)\n\n except Exception as exp:\n abort(exp.code)","def get_products(self):\n con = dbcon()\n cur = con.cursor()\n cur.execute(\"SELECT * FROM products;\")\n res = cur.fetchall()\n if res:\n prdcts=[]\n for prodct_item in res:\n picked_prdct = {\n 'product_id':prodct_item[0],\n 'product_name':prodct_item[1],\n 'price':prodct_item[2],\n 'quantity':prodct_item[3]\n }\n prdcts.append(picked_prdct)\n return jsonify({\"Products\": prdcts}), 200\n return jsonify({\"message\":\"No products in store\"})","def get_books():\n return jsonify({'books': Book.get_all_books()})","def get_books():\n return jsonify({'books': Book.get_all_books()})","def item_categories(request):\n all_item_categories = ItemType.objects.all() # Get all product_categories\n if request.method == 'GET':\n if all_item_categories:\n item_category_serializer = ItemCategorySerializer(all_item_categories, many=True)\n return Response(item_category_serializer.data, status=status.HTTP_200_OK)\n else:\n return Response(messages.EMPTY_PRODUCT_CATEGORIES, status=status.HTTP_204_NO_CONTENT)","def read_catalog():\n categories = session.query(Category).all()\n items = session.query(CatalogItem).order_by(CatalogItem.id.desc())\n quantity = items.count()\n return categories, items, quantity","def read_all():\r\n categories = Category.query.all()\r\n # Serialize the data for the response\r\n category_schema = CategorySchema(many=True)\r\n print('***********************************************************')\r\n return category_schema.dump(categories)","def jsonify_all(cls):\n return jsonify(accounts=[account.as_dict() for account in cls.query.all()])","def all_entries(cls):\n info = Diary.entries\n response = jsonify({\"data\": info})\n response.status_code = 200\n return response","def list_items(self) -> List[Dict[str, Any]]:\n return [c.to_dict() for c in self._objects.values()]","def list_products(admin):\n fields = [\n \"id\",\n \"name\",\n \"price\",\n \"barcode\",\n \"active\",\n \"countable\",\n \"purchase_sum\",\n \"replenishment_sum\",\n \"balance_score\",\n \"revocable\",\n \"imagename\",\n \"tags\",\n \"creation_date\",\n ]\n\n query = QueryFromRequestParameters(Product, request.args, fields)\n result, content_range = query.result()\n products = convert_minimal(result, fields)\n for product in products:\n product[\"tags\"] = [t.id for t in product[\"tags\"]]\n response = jsonify(products)\n response.headers[\"Content-Range\"] = content_range\n return response","def browse_category(request):\n\n result = {'categories':[], 'products':[]}\n\n u = request.user\n\n page = request.POST.get('page', 1)\n\n cat = Category.objects.get(id=request.POST['cat_id'])\n if cat.children.count() > 0:\n result['categories'] = [c.get_json() for c in cat.children.all()]\n else:\n # display items\n result = Product.objects.filter_category(cat.category_id, page, u) \n\n return JSONHttpResponse(result)","def get_stores():\n stores = Store.query # no need to order\n stores_data = [store.to_dict() for store in stores.all()]\n return jsonify(stores=stores_data)","def get_catergories(request):\n shop_obj = Shop.objects.get(user=request.user)\n shop_categories = shop_obj.categories\n value_added = list(\n map(\n lambda x: {\n \"name\": x[\"name\"],\n \"slug\": x[\"slug\"],\n \"public_slug\": x[\"public_slug\"],\n \"product_count\": Products.objects.filter(\n shop_rel=shop_obj, genre__slug=x[\"slug\"]\n ).count(),\n },\n shop_categories,\n )\n )\n resp_payload = {\"shop_categories\": value_added}\n return Response(data=resp_payload, status=status.HTTP_200_OK)","def list():\n trucks = Foodtruck.query.all()\n return jsonify(foodtrucks=[truck.to_dict() for truck in trucks])","def json_view(self, recursive=False):\n\n context = self.context.aq_inner\n data = self.export(context, recursive=recursive)\n pretty = json.dumps(data, sort_keys=True, indent=4)\n self.request.response.setHeader(\"Content-type\", \"application/json\")\n return pretty","def show_all_amenities():\n\n amenities = storage.all(Amenity).values()\n new_list = []\n for amenity in amenities:\n new_list.append(amenity.to_dict())\n return jsonify(new_list)","def get_menu_items(request):\n\n cat_id = request.POST.get('cat_id', None)\n menu_items = MenuItem.objects.filter(category_id=cat_id)\n context = {\n 'menu_items': menu_items\n }\n menu_items_view = render_to_string('HotelMgmt/menu_items.html', context)\n\n return JsonResponse({'menu_items_view': menu_items_view})","def api_asset_list():\n return jsonify(app.bank.to_list()), 200","def get_ingredients(request):\n items = Ingredient.objects.all().order_by('name')\n\n # return list of {item.name: item.pk}\n context = []\n for item in items:\n context.append({item.name: item.pk})\n\n return HttpResponse(json.dumps(context), content_type='application/json')","def get_categories():\n categories = app.preprocessed.uniq_categs\n result = {\n 'success': True,\n 'data': {\n 'categories': categories\n }\n }\n return jsonify(result)","def get_all(self) -> tuple:\n items = self.model.get_all()\n\n return {'items': list_map(items)}, 200","def compService():\n return jsonify(compileService.getItems())","def data_json(request):\n json_data = []\n for resource in Resource.objects.all():\n record = {} \n record['title'] = resource.name\n record['description'] = resource.description\n record['keyword'] = resource.csw_keywords.split(',')\n record['modified'] = resource.last_updated\n record['publisher'] = resource.organization\n record['contactPoint'] = resource.metadata_contact\n record['mbox'] = resource.contact_email\n record['identifier'] = resource.csw_identifier\n if resource.is_published:\n record['accessLevel'] = 'public'\n else:\n record['accessLevel'] = 'non-public'\n\n json_data.append(record)\n\n return HttpResponse(json.dumps(json_data), 'application/json')","def amenity_ret():\n ame_list = []\n all_objs = storage.all(\"Amenity\")\n for obj in all_objs.values():\n ame_list.append(obj.to_dict())\n return jsonify(ame_list)","def categories():\n\tcategories = [\n\t\t'News',\n\t\t'Technology',\n\t\t'Music',\n\t\t'Sports'\n\t]\n\tresponse = { 'response': categories }\n\treturn jsonify(response)","def read_category_items():\n items = session.query(CatalogItem).order_by(CatalogItem.id.desc())\n return items","def easyCategory():\n return prepJSON(cs411_dash.easyCategory())","def getItems(self): \n items = []\n if self.itemCount > 0:\n \n site = getSite()\n \n \n # Make string path relative to the site root\n # E.g. string path \"news\" becomes \"/yoursiteid/news\"\n site_path = site.getPhysicalPath();\n \n path = \"/\".join(site_path) + \"/\" + self.path \n \n #if self.itemPortalType2 != None:\n # types.append(self.itemPortalType2) \n \n #print \"Querying by:\" + type + \" \" + path\n content_by_type = self.context.portal_catalog(path={ \"query\": path, \"depth\" :9 }, \n sort_on=\"created\", \n sort_order=\"reverse\")[0:self.itemCount]\n\n \n items += [ brain.getObject() for brain in content_by_type ]\n\n return items","def getAllItemsList():\n return Gw2Spidy._request('all-items', 'all')['results']","def deserialize_catalog(catalog, client):\n try:\n data = json.loads(catalog)\n except Exception:\n data = catalog\n for item in data:\n client.data.add_by_path(json.loads(item))\n return client","def get_companies():\n all_companies = storage.all(Company).values()\n list_companies = []\n for company in all_companies:\n list_companies.append(company.to_dict())\n return jsonify(list_companies)","def get_products():\n products = db.session.query(Product).all()\n product_details = {}\n\n for product in products:\n product_details[product.product_id] = product.name\n\n return jsonify(product_details)","def amenities_all():\n return jsonify(list(map(lambda x: x.to_dict(),\n list(storage.all(Amenity).values()))))","def get_categories():\n categories = Category.query.all()\n formatted_categories = {}\n for category in categories:\n formatted_categories[category.id] = category.type\n\n return jsonify({\n 'success': True,\n 'categories': formatted_categories,\n 'total_categories': len(categories)\n })","def get_store_components():\n store_components = StoreComponent.query # no need to order\n store_components_data = [\n component.to_dict() for component in store_components.all()]\n return jsonify(store_components=store_components_data)","def get_citizens():\n response = table.scan()[\"Items\"]\n logger.info(\"All citizens returned\")\n return jsonify(response)","def get_items(self):\n return []","def categoriesJSON():\n\n try:\n categories = session.query(Category).all()\n return jsonify(categories=[r.serialize for r in categories])\n except Exception as e:\n return '''There was a problem with your query %s, please Verify,\n Redirecting to main page...\n <script> setTimeout(function() {\n window.location.href = \"/\";\n }, 2000);\n </script> ''' % (str(e))","def get_categories():\n categories = Category.query.order_by(Category.id).all()\n categories = {category.id: category.name for category in categories}\n\n response = jsonify({\"success\": True, \"categories\": categories})\n\n return response","def all(cls):\n cls.logger.info(\"Processing all Shopcart Items\")\n return cls.query.order_by(cls.id).all()","def test_api_ucs_get_catalog(self):\n api_data = request(\"get\", \"/sys\")\n self.assertEqual(api_data['status'], 200,\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\n total_elements = 0\n for elementTypes in api_data[\"json\"]:\n for element in api_data[\"json\"][str(elementTypes)]:\n api_data_c = request(\"get\", \"/catalog\",\n query={\"identifier\": element[\"relative_path\"].strip(\"/\")})\n self.assertEqual(api_data_c['status'], 200,\n 'Incorrect HTTP return code, expected 200, got:' +\n str(api_data_c['status']))\n total_elements += 1\n self.assertGreater(total_elements, 0, \"Zero catalog elements found\")\n # TO DO: deeper check on the catalog data","def product_list(request):\n error = {\n 'status': False,\n 'name': None,\n 'text': None,\n 'level': None,\n 'debug': None\n }\n\n limit, error = get_limit(request, error)\n\n serializer = FreshSerializer()\n queryset = Product.objects.all()[:limit]\n\n if not queryset:\n error = {\n \"status\": True,\n \"name\": \"No Products\",\n \"text\": \"No Products found\",\n \"level\": \"Information\",\n \"debug\": \"\"\n }\n\n data = {\n \"products\": json.loads(serializer.serialize(queryset)),\n \"error\": error\n }\n\n return HttpResponse(json.dumps(data), content_type=\"application/json\")"],"string":"[\n \"def catalog_json():\\n all_categories = (session.query(Categories).all())\\n all_items = (session.query(Items).all())\\n return jsonify(categories=([all_categories.serialize\\n for all_categories in all_categories]),\\n items=([all_items.serialize\\n for all_items in all_items]))\",\n \"def catalog_json():\\n catalog_json = []\\n try:\\n all_categories = session.query(Category).all()\\n for category in all_categories:\\n items_for_category = session.query(\\n Item).filter_by(\\n category_id=category.id).all()\\n items = []\\n for current_item in items_for_category:\\n items.append(current_item.serialize)\\n catalog_json.append({\\n 'category_name': category.name,\\n 'category_id': category.id,\\n 'items': items\\n })\\n except Exception as e:\\n error = {\\n 'result': 'No catalog data: ' + str(e)\\n }\\n catalog_json.append(error)\\n return jsonify(catalog_json)\",\n \"def get_jsonified_catalogs():\\n\\n json = []\\n catalogs = session.query(Catalog).all()\\n\\n for catalog in catalogs:\\n catalog_json = {}\\n catalog_json[\\\"id\\\"] = catalog.id\\n catalog_json[\\\"name\\\"] = catalog.name\\n catalog_json[\\\"date\\\"] = catalog.date.strftime(\\\"%d %b %Y %H: %M: %S\\\")\\n catalog_json[\\\"items\\\"] = []\\n for item in catalog.items:\\n item_json = {}\\n item_json[\\\"id\\\"] = item.id\\n item_json[\\\"title\\\"] = item.title\\n item_json[\\\"desc\\\"] = item.desc\\n item_json[\\\"date\\\"] = item.date.strftime(\\\"%d %b %Y %H: %M: %S\\\")\\n item_json[\\\"catalog_id\\\"] = item.catalog_id\\n catalog_json[\\\"items\\\"].append(item_json)\\n json.append(catalog_json)\\n return jsonify(Catalogs=json)\",\n \"def rest_get_catalogue_handler():\\n cats = category.get_all_categories()\\n items = item.get_all_items()\\n result = {}\\n result['categories'] = [c.serialize for c in cats]\\n result['items'] = [i.serialize for i in items]\\n return jsonify(result)\",\n \"def get_catalog():\\n return jsonify(getCatalog())\",\n \"def all_items_handler():\\n items = getAllItems()\\n return jsonify(items=[i.serialize for i in items])\",\n \"def itemCatalogJSON(sport_id):\\n\\n sport = session.query(Sport).filter_by(id=sport_id).one()\\n items = session.query(Item).filter_by(\\n sport_id=sport_id).all()\\n return jsonify(Sport=[i.serialize for i in items])\",\n \"def getItemsJSON(category_id):\\r\\n items = session.query(Item).filter_by(category_id=category_id).all()\\r\\n return jsonify(Items=[i.serialize for i in items])\",\n \"def showCategoryItemsJSON(category_id):\\r\\n session = DBSession()\\r\\n items = session.query(Item).filter_by(category_id=category_id)\\r\\n return jsonify(Items=[i.serialize for i in items])\",\n \"def api_all():\\r\\n\\tconn = sqlite3.connect('Shopify_products.db')\\r\\n\\tconn.row_factory = dict_factory\\r\\n\\tcur = conn.cursor()\\r\\n\\tall_products = cur.execute('SELECT * FROM products WHERE inventory_count>0;').fetchall()\\r\\n\\treturn jsonify(all_products)\",\n \"def catalogItemJSON(sport_id, item_id):\\n\\n catalogItem = session.query(Item).filter_by(id=item_id).one()\\n return jsonify(Item=catalogItem.serialize)\",\n \"def catelogJSON():\\n categories = session.query(Category).all()\\n items = session.query(Item).all()\\n catelog = []\\n for i in categories:\\n li = []\\n for j in items:\\n if j.category_id == i.id:\\n temp = j.serialize\\n li += [temp]\\n temp = i.serialize\\n if len(li) > 0:\\n temp['Items'] = li\\n catelog += [temp]\\n\\n return jsonify(Categories=catelog)\",\n \"def get_items_for_catalog(catalog_id):\\n pass\",\n \"def allCategoriesJSON():\\n categories = db_session.query(Category).all()\\n return jsonify(categories=[c.serialize for c in categories])\",\n \"def all_categories_handler():\\n categories = getAllCategories()\\n return jsonify(categories=[i.serialize for i in categories])\",\n \"def json(self):\\n return {\\\"name\\\": self.name,\\n \\\"items\\\": [item.json() for item in self.item]} # self.name==storeObj.name and self.item==storeObj.item\",\n \"def categoryItemJSON(category_id):\\n category = db.getByCategory(category_id)\\n items = db.getItemsByCategory(category_id)\\n return jsonify(Items=[i.serialize for i in items])\",\n \"def get_catalog_items(id):\\n\\n username = login_session.get('username', None)\\n catalogs = session.query(Catalog).all()\\n selected_catalog = session.query(Catalog).filter_by(id=id).one()\\n items = selected_catalog.items\\n catalogs_display = [\\n {\\n 'id': catalog.id,\\n 'name': catalog.name\\n } for catalog in catalogs]\\n items_display = [{'id': item.id, 'title': item.title} for item in items]\\n items_summary = '{0} Items ({1} items)'.format(\\n selected_catalog.name,\\n len(items_display))\\n return render_template(\\n 'home.html',\\n catalogs_display=catalogs_display,\\n items_display=items_display,\\n items_summary=items_summary,\\n username=username)\",\n \"def getCatalogs():\",\n \"def showCategoriesJSON():\\r\\n session = DBSession()\\r\\n categories = session.query(Category).all()\\r\\n return jsonify(Categories=[c.serialize for c in categories])\",\n \"def categoryItemJSON(category_id):\\n category = session.query(Category).\\\\\\n filter_by(id=category_id).one()\\n items = session.query(Item).\\\\\\n filter_by(category_id=category_id).all()\\n return jsonify(Items=[i.serialize for i in items])\",\n \"def json_api():\\n if 'category' in request.args:\\n sqlsession = SQLSESSION()\\n category = sqlsession.query(Category)\\\\\\n .filter_by(name=request.args['category']).first()\\n items = sqlsession.query(Item).filter_by(category_id=category.id)\\\\\\n .all()\\n return json.dumps({'category_id': category.id,\\n 'category_name': category.name,\\n 'items': [item.serialize() for item in items]})\\n elif 'item' in request.args:\\n sqlsession = SQLSESSION()\\n items = sqlsession.query(Item).filter_by(name=request.args['item'])\\\\\\n .all()\\n return json.dumps([item.serialize() for item in items])\\n sqlsession = SQLSESSION()\\n categories = sqlsession.query(Category).all()\\n items = sqlsession.query(Item).all()\\n return json.dumps(\\n {'categories': [cat.serialize() for cat in categories],\\n 'items': [item.serialize() for item in items]})\",\n \"def categoriesJSON():\\n categories = session.query(Category).all()\\n return jsonify(Categories=[r.serialize for r in categories])\",\n \"def api_category_items(category_id):\\n items = session.query(Item).filter(Item.category_id == category_id)\\n return jsonify(json_list=[i.to_json() for i in items.all()])\",\n \"def getCategoriesJSON():\\r\\n categories = session.query(Category).all()\\r\\n return jsonify(Categories=[c.serialize for c in categories])\",\n \"def get_categories(request):\\n return JsonResponse(get_all_objects(Category, CategorySerializer), safe=False)\",\n \"def categoryItemsJSON(category_id):\\n\\n try:\\n category = session.query(Category).filter_by(id=category_id).one()\\n items = session.query(ListItem).filter_by(\\n category_id=category_id).all()\\n return jsonify(ListItems=[i.serialize for i in items])\\n except Exception as e:\\n return '''There was a problem with your query %s, please Verify,\\n Redirecting to main page...\\n <script> setTimeout(function() {\\n window.location.href = \\\"/\\\";\\n }, 2000);\\n </script> ''' % (str(e))\",\n \"def products():\\n try:\\n return jsonify(get_product_caching_service().jsonofied_product_map)\\n except Exception as exception:\\n return jsonify({'Something went wrong: ': exception})\",\n \"def catalog():\\n session['target'] = \\\"/\\\"\\n sqlsession = SQLSESSION()\\n items = sqlsession.query(Item, Category)\\\\\\n .join(Category).order_by(Item.create_date).limit(10)\\n categories = sqlsession.query(Category).all()\\n return render_template(\\\"catalog.html\\\",\\n items=items,\\n categories=categories,\\n item_title=\\\"Latest Items\\\")\",\n \"def api_categories():\\n categories = session.query(Category)\\n return jsonify(json_list=[i.to_json() for i in categories.all()])\",\n \"def show_item_json(category, item):\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n item = (session.query(Items)\\n .filter_by(name=item.replace('-', ' '))\\n .one())\\n return jsonify(item=[item.serialize])\",\n \"def get_categories():\\n categories = [c.serialize for c in session.query(Category).all()]\\n for c in range(len(categories)):\\n items = [\\n i.serialize for i in session.query(Item).filter_by(\\n category_id=categories[c][\\\"id\\\"]).all()]\\n if items:\\n categories[c][\\\"Item\\\"] = items\\n return jsonify(Category=categories)\",\n \"def list(self, request):\\n item_categories = ItemCategory.objects.all()\\n\\n serializer = ItemCategorySerializer(\\n item_categories, many=True, context={'request': request})\\n return Response(serializer.data)\",\n \"def get_catalog(self):\\n\\n rep = req.get_json(self.CATALOG)\\n repo_list = rep[\\\"repositories\\\"]\\n\\n for repo in repo_list:\\n self.list.append(Repository(repo))\\n\\n return self.list\",\n \"def itemJSON(category_id, item_id):\\n item = session.query(Item).filter_by(id=item_id).one()\\n return jsonify(Item=item.serialize)\",\n \"def serialize_catalog(catalog, with_extra=False):\\n data, acls, collabs = _recursve_catalog(catalog)\\n if with_extra:\\n return json.dumps(data), json.dumps(acls), json.dumps(collabs)\\n else:\\n return json.dumps(data)\",\n \"def get_all_categories():\\n return jsonify({\\n \\\"success\\\": True,\\n \\\"categories\\\": _read_all_categories()\\n })\",\n \"def api_display_cart():\\r\\n\\tconn = sqlite3.connect('Shopify_products.db')\\r\\n\\tconn.row_factory = dict_factory\\r\\n\\tcur = conn.cursor()\\r\\n\\tcart = cur.execute('SELECT * FROM cart;').fetchall()\\r\\n\\tcart.append(cur.execute('SELECT SUM(price) from cart;').fetchone())\\r\\n\\treturn jsonify(cart)\",\n \"def query_items_handler(query):\\n items = getItemsByName(query)\\n return jsonify(items=[i.serialize for i in items])\",\n \"def show_category_json(category):\\n category = (session.query(Categories)\\n .filter_by(name=category.replace('-', ' '))\\n .one())\\n category_items = (session.query(Items)\\n .filter_by(category_id=category.id)\\n .order_by(Items.name)\\n .all())\\n return jsonify(category=[category.serialize],\\n items=([category_items.serialize\\n for category_items in category_items]))\",\n \"def products_with_inventory():\\n try:\\n return jsonify(get_product_caching_service().jsonified_map)\\n except Exception as exception:\\n return jsonify({'Something went wrong ': exception})\",\n \"def get(cls):\\n return {'products': [product.to_json() for product in ProductModel.find_all()]}\",\n \"def amenity_get_all():\\n am_list = []\\n am_obj = storage.all(\\\"Amenity\\\")\\n for obj in am_obj.values():\\n am_list.append(obj.to_json())\\n\\n return jsonify(am_list)\",\n \"def browse_categories(request):\\n\\n result = {}\\n\\n u = request.user\\n\\n top = Category.objects.get(name=\\\"Best Buy\\\")\\n result['categories'] = [c.get_json() for c in top.children.all()]\\n \\n return JSONHttpResponse(result)\",\n \"def list_catalogs(self):\\n return self._json_object_field_to_list(\\n self._get_catalogs_json(), self.__MISSION_STRING)\",\n \"def showItemJSON(category_id, item_id):\\r\\n session = DBSession()\\r\\n item = session.query(Item).filter_by(id=item_id).one()\\r\\n return jsonify(Item=item.serialize)\",\n \"def to_json(self):\\n return {\\n \\\"item_name\\\": self.item_name,\\n \\\"summary\\\": self.summary,\\n \\\"content\\\": self.content,\\n \\\"date_published\\\": self.date_published,\\n \\\"item_slug\\\": self.item_slug,\\n \\\"category_name\\\": self.category_name,\\n }\",\n \"def get_items_by_cart_page(request):\\n items = Item.get_items_by_cart(request.GET['cart_id'])\\n items = models_to_json(items)\\n return JsonResponse({'items': items})\",\n \"def products(self):\\n response = requests.get(self._url(self._PRODUCTS_PATH), headers=self._headers)\\n return response.json()\",\n \"def cat_results_react():\\n\\n cats = petfinder.search_data_map()\\n cats = list(cats.values())\\n\\n return jsonify(cats)\",\n \"def get(self):\\n return GenericGet().get_catalogs()\",\n \"def get_all_data():\\n return jsonify(service.get_all_data())\",\n \"def get_all(self) -> RestaurantCatalog:\\n catalog = RestaurantCatalog()\\n catalog.add_many(list(self.__data.values()))\\n return catalog\",\n \"def getall():\\n elements = Advertisements().get_all_elements()\\n data = jsonify(elements)\\n data.statut_code = 200\\n return data\",\n \"def get_items():\\n return requester.perform_request(Uri.items)\",\n \"def collections():\\n\\tcollections = models.Collection.query.all()\\n\\tif not collections:\\n\\t\\tabort(404)\\n\\tresponse = { 'collections': [c.dictionary() for c in collections] }\\n\\treturn jsonify(response)\",\n \"def categories_json():\\n try:\\n categories = session.query(Category).all()\\n return jsonify(categories=[category.serialize for category in categories])\\n except Exception as inst:\\n print(type(inst))\\n print(inst.args)\\n print(inst)\",\n \"def get_categories():\\n try:\\n result = {\\n \\\"success\\\": True,\\n \\\"categories\\\": get_all_categories()\\n }\\n return jsonify(result)\\n\\n except Exception as exp:\\n abort(exp.code)\",\n \"def get_products(self):\\n con = dbcon()\\n cur = con.cursor()\\n cur.execute(\\\"SELECT * FROM products;\\\")\\n res = cur.fetchall()\\n if res:\\n prdcts=[]\\n for prodct_item in res:\\n picked_prdct = {\\n 'product_id':prodct_item[0],\\n 'product_name':prodct_item[1],\\n 'price':prodct_item[2],\\n 'quantity':prodct_item[3]\\n }\\n prdcts.append(picked_prdct)\\n return jsonify({\\\"Products\\\": prdcts}), 200\\n return jsonify({\\\"message\\\":\\\"No products in store\\\"})\",\n \"def get_books():\\n return jsonify({'books': Book.get_all_books()})\",\n \"def get_books():\\n return jsonify({'books': Book.get_all_books()})\",\n \"def item_categories(request):\\n all_item_categories = ItemType.objects.all() # Get all product_categories\\n if request.method == 'GET':\\n if all_item_categories:\\n item_category_serializer = ItemCategorySerializer(all_item_categories, many=True)\\n return Response(item_category_serializer.data, status=status.HTTP_200_OK)\\n else:\\n return Response(messages.EMPTY_PRODUCT_CATEGORIES, status=status.HTTP_204_NO_CONTENT)\",\n \"def read_catalog():\\n categories = session.query(Category).all()\\n items = session.query(CatalogItem).order_by(CatalogItem.id.desc())\\n quantity = items.count()\\n return categories, items, quantity\",\n \"def read_all():\\r\\n categories = Category.query.all()\\r\\n # Serialize the data for the response\\r\\n category_schema = CategorySchema(many=True)\\r\\n print('***********************************************************')\\r\\n return category_schema.dump(categories)\",\n \"def jsonify_all(cls):\\n return jsonify(accounts=[account.as_dict() for account in cls.query.all()])\",\n \"def all_entries(cls):\\n info = Diary.entries\\n response = jsonify({\\\"data\\\": info})\\n response.status_code = 200\\n return response\",\n \"def list_items(self) -> List[Dict[str, Any]]:\\n return [c.to_dict() for c in self._objects.values()]\",\n \"def list_products(admin):\\n fields = [\\n \\\"id\\\",\\n \\\"name\\\",\\n \\\"price\\\",\\n \\\"barcode\\\",\\n \\\"active\\\",\\n \\\"countable\\\",\\n \\\"purchase_sum\\\",\\n \\\"replenishment_sum\\\",\\n \\\"balance_score\\\",\\n \\\"revocable\\\",\\n \\\"imagename\\\",\\n \\\"tags\\\",\\n \\\"creation_date\\\",\\n ]\\n\\n query = QueryFromRequestParameters(Product, request.args, fields)\\n result, content_range = query.result()\\n products = convert_minimal(result, fields)\\n for product in products:\\n product[\\\"tags\\\"] = [t.id for t in product[\\\"tags\\\"]]\\n response = jsonify(products)\\n response.headers[\\\"Content-Range\\\"] = content_range\\n return response\",\n \"def browse_category(request):\\n\\n result = {'categories':[], 'products':[]}\\n\\n u = request.user\\n\\n page = request.POST.get('page', 1)\\n\\n cat = Category.objects.get(id=request.POST['cat_id'])\\n if cat.children.count() > 0:\\n result['categories'] = [c.get_json() for c in cat.children.all()]\\n else:\\n # display items\\n result = Product.objects.filter_category(cat.category_id, page, u) \\n\\n return JSONHttpResponse(result)\",\n \"def get_stores():\\n stores = Store.query # no need to order\\n stores_data = [store.to_dict() for store in stores.all()]\\n return jsonify(stores=stores_data)\",\n \"def get_catergories(request):\\n shop_obj = Shop.objects.get(user=request.user)\\n shop_categories = shop_obj.categories\\n value_added = list(\\n map(\\n lambda x: {\\n \\\"name\\\": x[\\\"name\\\"],\\n \\\"slug\\\": x[\\\"slug\\\"],\\n \\\"public_slug\\\": x[\\\"public_slug\\\"],\\n \\\"product_count\\\": Products.objects.filter(\\n shop_rel=shop_obj, genre__slug=x[\\\"slug\\\"]\\n ).count(),\\n },\\n shop_categories,\\n )\\n )\\n resp_payload = {\\\"shop_categories\\\": value_added}\\n return Response(data=resp_payload, status=status.HTTP_200_OK)\",\n \"def list():\\n trucks = Foodtruck.query.all()\\n return jsonify(foodtrucks=[truck.to_dict() for truck in trucks])\",\n \"def json_view(self, recursive=False):\\n\\n context = self.context.aq_inner\\n data = self.export(context, recursive=recursive)\\n pretty = json.dumps(data, sort_keys=True, indent=4)\\n self.request.response.setHeader(\\\"Content-type\\\", \\\"application/json\\\")\\n return pretty\",\n \"def show_all_amenities():\\n\\n amenities = storage.all(Amenity).values()\\n new_list = []\\n for amenity in amenities:\\n new_list.append(amenity.to_dict())\\n return jsonify(new_list)\",\n \"def get_menu_items(request):\\n\\n cat_id = request.POST.get('cat_id', None)\\n menu_items = MenuItem.objects.filter(category_id=cat_id)\\n context = {\\n 'menu_items': menu_items\\n }\\n menu_items_view = render_to_string('HotelMgmt/menu_items.html', context)\\n\\n return JsonResponse({'menu_items_view': menu_items_view})\",\n \"def api_asset_list():\\n return jsonify(app.bank.to_list()), 200\",\n \"def get_ingredients(request):\\n items = Ingredient.objects.all().order_by('name')\\n\\n # return list of {item.name: item.pk}\\n context = []\\n for item in items:\\n context.append({item.name: item.pk})\\n\\n return HttpResponse(json.dumps(context), content_type='application/json')\",\n \"def get_categories():\\n categories = app.preprocessed.uniq_categs\\n result = {\\n 'success': True,\\n 'data': {\\n 'categories': categories\\n }\\n }\\n return jsonify(result)\",\n \"def get_all(self) -> tuple:\\n items = self.model.get_all()\\n\\n return {'items': list_map(items)}, 200\",\n \"def compService():\\n return jsonify(compileService.getItems())\",\n \"def data_json(request):\\n json_data = []\\n for resource in Resource.objects.all():\\n record = {} \\n record['title'] = resource.name\\n record['description'] = resource.description\\n record['keyword'] = resource.csw_keywords.split(',')\\n record['modified'] = resource.last_updated\\n record['publisher'] = resource.organization\\n record['contactPoint'] = resource.metadata_contact\\n record['mbox'] = resource.contact_email\\n record['identifier'] = resource.csw_identifier\\n if resource.is_published:\\n record['accessLevel'] = 'public'\\n else:\\n record['accessLevel'] = 'non-public'\\n\\n json_data.append(record)\\n\\n return HttpResponse(json.dumps(json_data), 'application/json')\",\n \"def amenity_ret():\\n ame_list = []\\n all_objs = storage.all(\\\"Amenity\\\")\\n for obj in all_objs.values():\\n ame_list.append(obj.to_dict())\\n return jsonify(ame_list)\",\n \"def categories():\\n\\tcategories = [\\n\\t\\t'News',\\n\\t\\t'Technology',\\n\\t\\t'Music',\\n\\t\\t'Sports'\\n\\t]\\n\\tresponse = { 'response': categories }\\n\\treturn jsonify(response)\",\n \"def read_category_items():\\n items = session.query(CatalogItem).order_by(CatalogItem.id.desc())\\n return items\",\n \"def easyCategory():\\n return prepJSON(cs411_dash.easyCategory())\",\n \"def getItems(self): \\n items = []\\n if self.itemCount > 0:\\n \\n site = getSite()\\n \\n \\n # Make string path relative to the site root\\n # E.g. string path \\\"news\\\" becomes \\\"/yoursiteid/news\\\"\\n site_path = site.getPhysicalPath();\\n \\n path = \\\"/\\\".join(site_path) + \\\"/\\\" + self.path \\n \\n #if self.itemPortalType2 != None:\\n # types.append(self.itemPortalType2) \\n \\n #print \\\"Querying by:\\\" + type + \\\" \\\" + path\\n content_by_type = self.context.portal_catalog(path={ \\\"query\\\": path, \\\"depth\\\" :9 }, \\n sort_on=\\\"created\\\", \\n sort_order=\\\"reverse\\\")[0:self.itemCount]\\n\\n \\n items += [ brain.getObject() for brain in content_by_type ]\\n\\n return items\",\n \"def getAllItemsList():\\n return Gw2Spidy._request('all-items', 'all')['results']\",\n \"def deserialize_catalog(catalog, client):\\n try:\\n data = json.loads(catalog)\\n except Exception:\\n data = catalog\\n for item in data:\\n client.data.add_by_path(json.loads(item))\\n return client\",\n \"def get_companies():\\n all_companies = storage.all(Company).values()\\n list_companies = []\\n for company in all_companies:\\n list_companies.append(company.to_dict())\\n return jsonify(list_companies)\",\n \"def get_products():\\n products = db.session.query(Product).all()\\n product_details = {}\\n\\n for product in products:\\n product_details[product.product_id] = product.name\\n\\n return jsonify(product_details)\",\n \"def amenities_all():\\n return jsonify(list(map(lambda x: x.to_dict(),\\n list(storage.all(Amenity).values()))))\",\n \"def get_categories():\\n categories = Category.query.all()\\n formatted_categories = {}\\n for category in categories:\\n formatted_categories[category.id] = category.type\\n\\n return jsonify({\\n 'success': True,\\n 'categories': formatted_categories,\\n 'total_categories': len(categories)\\n })\",\n \"def get_store_components():\\n store_components = StoreComponent.query # no need to order\\n store_components_data = [\\n component.to_dict() for component in store_components.all()]\\n return jsonify(store_components=store_components_data)\",\n \"def get_citizens():\\n response = table.scan()[\\\"Items\\\"]\\n logger.info(\\\"All citizens returned\\\")\\n return jsonify(response)\",\n \"def get_items(self):\\n return []\",\n \"def categoriesJSON():\\n\\n try:\\n categories = session.query(Category).all()\\n return jsonify(categories=[r.serialize for r in categories])\\n except Exception as e:\\n return '''There was a problem with your query %s, please Verify,\\n Redirecting to main page...\\n <script> setTimeout(function() {\\n window.location.href = \\\"/\\\";\\n }, 2000);\\n </script> ''' % (str(e))\",\n \"def get_categories():\\n categories = Category.query.order_by(Category.id).all()\\n categories = {category.id: category.name for category in categories}\\n\\n response = jsonify({\\\"success\\\": True, \\\"categories\\\": categories})\\n\\n return response\",\n \"def all(cls):\\n cls.logger.info(\\\"Processing all Shopcart Items\\\")\\n return cls.query.order_by(cls.id).all()\",\n \"def test_api_ucs_get_catalog(self):\\n api_data = request(\\\"get\\\", \\\"/sys\\\")\\n self.assertEqual(api_data['status'], 200,\\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\\n total_elements = 0\\n for elementTypes in api_data[\\\"json\\\"]:\\n for element in api_data[\\\"json\\\"][str(elementTypes)]:\\n api_data_c = request(\\\"get\\\", \\\"/catalog\\\",\\n query={\\\"identifier\\\": element[\\\"relative_path\\\"].strip(\\\"/\\\")})\\n self.assertEqual(api_data_c['status'], 200,\\n 'Incorrect HTTP return code, expected 200, got:' +\\n str(api_data_c['status']))\\n total_elements += 1\\n self.assertGreater(total_elements, 0, \\\"Zero catalog elements found\\\")\\n # TO DO: deeper check on the catalog data\",\n \"def product_list(request):\\n error = {\\n 'status': False,\\n 'name': None,\\n 'text': None,\\n 'level': None,\\n 'debug': None\\n }\\n\\n limit, error = get_limit(request, error)\\n\\n serializer = FreshSerializer()\\n queryset = Product.objects.all()[:limit]\\n\\n if not queryset:\\n error = {\\n \\\"status\\\": True,\\n \\\"name\\\": \\\"No Products\\\",\\n \\\"text\\\": \\\"No Products found\\\",\\n \\\"level\\\": \\\"Information\\\",\\n \\\"debug\\\": \\\"\\\"\\n }\\n\\n data = {\\n \\\"products\\\": json.loads(serializer.serialize(queryset)),\\n \\\"error\\\": error\\n }\\n\\n return HttpResponse(json.dumps(data), content_type=\\\"application/json\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.853434","0.83946824","0.7997253","0.7965265","0.7584442","0.7521632","0.71851015","0.7113346","0.7080814","0.70294416","0.70173","0.6980845","0.6839632","0.68100387","0.6775649","0.67730457","0.6750319","0.67496765","0.66796345","0.6647565","0.66201764","0.65568656","0.65460783","0.6521912","0.6486054","0.64760196","0.644979","0.6389305","0.6356084","0.63139546","0.63121355","0.6306252","0.6303249","0.6300872","0.62999535","0.6298116","0.62755364","0.6272725","0.6263536","0.6259343","0.6258147","0.62394154","0.6224005","0.62120414","0.6207015","0.61857927","0.6185695","0.6184929","0.61795366","0.6171552","0.6153313","0.61460835","0.6133556","0.61160994","0.608977","0.60720426","0.60307604","0.60249025","0.5984245","0.59455514","0.59455514","0.5929468","0.59274113","0.59273994","0.592184","0.5921658","0.59174734","0.5914368","0.5911774","0.59108055","0.5910211","0.5899921","0.5890979","0.58864653","0.5875169","0.5874757","0.5871405","0.58713824","0.58696514","0.58663934","0.5864057","0.58475876","0.5846851","0.58401453","0.5837071","0.5816565","0.5813575","0.58097494","0.57947946","0.5784738","0.5777817","0.5770915","0.57697976","0.57686377","0.5763989","0.5761883","0.5754721","0.57414633","0.5735363","0.5724303"],"string":"[\n \"0.853434\",\n \"0.83946824\",\n \"0.7997253\",\n \"0.7965265\",\n \"0.7584442\",\n \"0.7521632\",\n \"0.71851015\",\n \"0.7113346\",\n \"0.7080814\",\n \"0.70294416\",\n \"0.70173\",\n \"0.6980845\",\n \"0.6839632\",\n \"0.68100387\",\n \"0.6775649\",\n \"0.67730457\",\n \"0.6750319\",\n \"0.67496765\",\n \"0.66796345\",\n \"0.6647565\",\n \"0.66201764\",\n \"0.65568656\",\n \"0.65460783\",\n \"0.6521912\",\n \"0.6486054\",\n \"0.64760196\",\n \"0.644979\",\n \"0.6389305\",\n \"0.6356084\",\n \"0.63139546\",\n \"0.63121355\",\n \"0.6306252\",\n \"0.6303249\",\n \"0.6300872\",\n \"0.62999535\",\n \"0.6298116\",\n \"0.62755364\",\n \"0.6272725\",\n \"0.6263536\",\n \"0.6259343\",\n \"0.6258147\",\n \"0.62394154\",\n \"0.6224005\",\n \"0.62120414\",\n \"0.6207015\",\n \"0.61857927\",\n \"0.6185695\",\n \"0.6184929\",\n \"0.61795366\",\n \"0.6171552\",\n \"0.6153313\",\n \"0.61460835\",\n \"0.6133556\",\n \"0.61160994\",\n \"0.608977\",\n \"0.60720426\",\n \"0.60307604\",\n \"0.60249025\",\n \"0.5984245\",\n \"0.59455514\",\n \"0.59455514\",\n \"0.5929468\",\n \"0.59274113\",\n \"0.59273994\",\n \"0.592184\",\n \"0.5921658\",\n \"0.59174734\",\n \"0.5914368\",\n \"0.5911774\",\n \"0.59108055\",\n \"0.5910211\",\n \"0.5899921\",\n \"0.5890979\",\n \"0.58864653\",\n \"0.5875169\",\n \"0.5874757\",\n \"0.5871405\",\n \"0.58713824\",\n \"0.58696514\",\n \"0.58663934\",\n \"0.5864057\",\n \"0.58475876\",\n \"0.5846851\",\n \"0.58401453\",\n \"0.5837071\",\n \"0.5816565\",\n \"0.5813575\",\n \"0.58097494\",\n \"0.57947946\",\n \"0.5784738\",\n \"0.5777817\",\n \"0.5770915\",\n \"0.57697976\",\n \"0.57686377\",\n \"0.5763989\",\n \"0.5761883\",\n \"0.5754721\",\n \"0.57414633\",\n \"0.5735363\",\n \"0.5724303\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7908903"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":14892,"cells":{"query":{"kind":"string","value":"Checks if a string is palindromic."},"document":{"kind":"string","value":"def ispalindrome(string):\n if isinstance(string, (str, int, float)):\n string = str(string).replace(\" \", \"\").lower()\n if len(string) in [0,1]:\n return True\n half_index = len(string) // 2\n first = string[:half_index]\n second = string[-half_index:]\n if first == second[::-1]:\n return True\n else:\n return False\n else:\n print(\"ERROR: ispalindrome received invalid input.\\nREASON: input\",\n \"must be convertible to string format.\")"},"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 string_palidrome(word):\n if word == string_reverse(word):\n return True\n else:\n return False","def is_palindrome(string):\n return","def isPalindrome(s):\r\n return isPal(toChars(s))","def is_palindromic(n: int) -> bool:\n str_n = str(n)\n if str_n == str_n[::-1]:\n return True\n return False","def is_palindrome_v1(s):\n return reverse(s) == s","def isPalindromic(n: int):\n return str(n) == str(n)[::-1]","def check_palindrome():","def check_palindrome(s):\n return s[::-1] == s","def is_palindrome(string):\n return string[::-1] == string","def is_palindrome(string):\n if string == string[::-1]:\n return True\n return False","def is_palindromic(phrase):\n\n val = str(phrase).lower().replace(\" \", \"\")\n if val == val[::-1]: # Reverse order\n return True\n else:\n return False","def is_palindrome2(some_string):\n return reverse_string(some_string) == some_string","def check_palindrome(string):\n palindrome = ''.join(string).lower()\n if palindrome == palindrome[::-1]:\n return True\n else:\n return False","def isPalindrome(self, s: str) -> bool:\n s = s.translate(str.maketrans('','',string.punctuation)) # drop punctuation\n s = \"\".join(s.split()) # drop spaces\n s = s.lower() # casefold more agressive (ASCII vs UNICODE)\n\n return s == s[::-1]","def is_palindrome(string):\n string = string.upper()\n if reverse(string) == string:\n #use function reverse() to check if the reverse of the string is same as the original string\n return True\n else:\n return False","def is_palindrome(s):\n return s == s[::-1]","def check_palindrome(inp_string):\n if len(inp_string) <= 2:\n return False\n elif inp_string == inp_string[::-1]:\n return True\n else:\n return False","def palindrome(string: str) -> Bool:\n string_lower = string.lower()\n string_clean =","def validPalindrome(self, s: str) -> bool:\n n = len(s)\n i = 0\n j = n - 1\n while i < j:\n if s[i] == s[j]:\n i += 1\n j -= 1\n else:\n # error, for -1, start > end. Indexing is like range\n # return s[i:j] == s[i:j:-1] or s[i+1:j+1] == s[i+1:j+1:-1]\n return self.is_palindrome(s[i:j]) or self.is_palindrome(s[i+1:j+1])\n\n return True","def is_palindrome(s):\n\n def to_chars(s):\n s = s.lower()\n letters = ''\n for char in s:\n if char in 'abcdefghijklmnopqrstuvwxyz':\n letters += char\n return letters\n\n def is_pal(s):\n if len(s) <= 1:\n return True\n else:\n return s[0] == s[-1] and is_pal(s[1:-1])\n\n return is_pal(to_chars(s))","def is_palindrome(string):\n k, mid = len(string), len(string) // 2\n # checking even palindromes\n if k % 2 == 0:\n return string[:mid] == get_reverse_complement(string[mid:])\n # checking odd palindromes\n else:\n return string[:mid] == get_reverse_complement(string[mid + 1:])","def is_palindrome(word: str) -> bool:\n\n # Todo\n return False","def checkPalindrome(self, s: str) -> str:\n # return s[:len(s) // 2] == s[(len(s) + 1) // 2::-1]\n return s == s[::-1]","def is_palindrome(s):\n rev_str = \"\"\n for let in range(1, len(s) + 1):\n rev_str += s[-let]\n return rev_str == s","def is_palindrome(s):\n if isinstance(s, str):\n if s == s[::-1]:\n return True\n else:\n return False\n if isinstance(s, int):\n if str(s) == str(s)[::-1]:\n return True\n else:\n return False\n else:\n raise AssertionError(\"Please enter str\")","def isPalindrome(self, s: str) -> bool:\n if not s:\n return True\n # process the string\n s_processed = \"\"\n for i in s:\n if i.isalnum():\n s_processed += i.lower()\n # Check if palindrome\n return s_processed == s_processed[::-1] # String[::-1], O(n)","def isPalindrome(string):\n for i in range(len(string)//2):\n if string[i] != string[(i*-1)-1]:\n return False\n return True","def palindrome(string):\r\n if len(string) <= 1:\r\n return True\r\n else:","def is_palindrome_v2(s):\n n = len(s)\n\n return s[:n/2] == reverse(s[n-n/2:])","def is_palindrome(n):\n ns = str(n)\n for i in range(0, len(ns) // 2):\n if ns[i] != ns[len(ns) - 1 - i]: return False\n return True","def is_palindrome(str):\n n = len(str)\n for i in range(n//2): # loop to middle of string str\n if str[i] != str[-1-i]:\n return False # find a character doesn't match with its mirror-positioned character\n return True # reach this, then str is palindrome","def is_palindrome(word):\n if word == word[::-1]:\n return True\n else:\n return False","def is_palindrome(string):\r\n r_string = string[::-1]\r\n cnt = 0\r\n while cnt < len(string):\r\n if string[cnt] == r_string[cnt]:\r\n cnt += 1\r\n continue\r\n else:\r\n return False\r\n #cnt += 1\r\n return True","def palindrome(word):\n reverse = word[::-1]\n return word == reverse","def is_palindrome(s):\n i, end = 0, len(s) // 2\n while i < end:\n if s[i] != s[len(s) - i - 1]:\n return False\n i += 1\n return True","def is_palendrome(my_string):\n characters = []\n for char in my_string:\n characters.append(char)\n characters.reverse()\n reversed_string = \"\".join(characters)\n if my_string == reversed_string:\n return True\n else:\n return False","def is_palindrome(number):\r\n str_input = str(number)\r\n return str_input == reversed(str_input)","def isPalindromes(s):\n\n def toChar(s):\n s= s.lower()\n letters=''\n for c in s:\n if c in \"abcdefgh\":\n letters= letters+c\n return letters\n\n def isPal(s):\n if len(s) <=1:\n return True\n else:\n return s[0]==s[-1] and isPal(s[1:-1])\n return isPal(toChar(s))","def isPalindrome(self, s: str) -> bool:\n left, right = 0, len(s) - 1\n while left < right:\n while left < right and not s[left].isalnum(): # 注意while loop的嵌套\n left += 1\n while left < right and not s[right].isalnum():\n right -= 1\n if s[left].lower() != s[right].lower():\n return False\n left += 1\n right -= 1\n return True","def palCheck(input_string):\n\n # ADD NECESSARY LINES OF CODE SO THAT ALL UNITTESTS PASS\n\n d = Deque()\n for char in input_string:\n d.addFront(char)\n\n while d.size() > 1:\n firstChar = d.removeRear()\n lastChar = d.removeFront()\n if firstChar != lastChar:\n print(\"No, '\" + input_string + \"', is not a palindrom\")\n return False\n\n print(\"Yes, '\" + input_string + \"', is a palindrom!!\")\n return True","def is_pal(string):\n a = reversed(list(string))\n if list(a) == list(string):\n return True\n else:\n return False","def is_palindrome(num_in):\n if str(num_in) == str(num_in)[::-1]:\n return True\n\n return False","def is_pal(n):\r\n # Change the number into a string and then a list.\r\n as_list_of_chars = list(str(n))\r\n # Copy the list and reverse it.\r\n reversed_list_of_chars = list(as_list_of_chars)\r\n reversed_list_of_chars.reverse()\r\n # True if the list of chars is palindromic.\r\n return as_list_of_chars == reversed_list_of_chars","def is_palindrome(n):\n return(n == reverse(n))","def is_palindrome(num):\n\treversed_num = str(num)[::-1]\n\tif reversed_num == str(num): return True\n\telse: return False","def _is_palindrome(input_str, start, end):\n if start >= end:\n return True\n if input_str[start] != input_str[end]:\n return False\n else:\n return _is_palindrome(input_str, start + 1, end - 1)","def isPalindrome(word):\n\n input_str = IGNORE_NON_ALPHA_CHARACTER.sub(\"\", str(word)).casefold()\n return input_str == input_str[::-1]","def isPalindrome(n):\n str_n = str(n)\n return list(str_n) == list(reversed(str_n))","def part3():\n Input = raw_input('please enter a string:')\n for i in range(len(Input)):\n if Input[i] != Input[len(Input)-i-1]:\n print('It is not a palidrome')\n break\n else:\n i = i + 1","def palindrome_integer(string):\n integers = string.split(\" \")\n for integer in integers:\n reverse = str(int)[::-1]\n '''Check if palindrome not then return False'''\n if integer != reverse:\n return False\n return True","def is_palindrome(word):\n\t# The degenerate case is 1 letter or none. We consider these palindromes\n\tif len(word) <= 1:\n\t\treturn True\n\n\t# For something to be a palindrome, the first and last letters much match\n\t# and the string between them must also be a palindrome\n\tif first(word) == last(word) and is_palindrome(middle(word)):\n\t\treturn True\n\telse:\n\t\treturn False","def is_palindrome_v3(s):\n i = 0\n j = len(s)-1\n\n while i < j and s[i] == s[j]:\n i = i + 1\n j = j -1\n\n return j <= i","def is_palindrome(input_string):\n\n def _is_palindrome(input_str, start, end):\n \"\"\"Returns whether a string is a palindrome or not\n using recursion. Assumes string is not empty.\n \"\"\"\n if start >= end:\n return True\n if input_str[start] != input_str[end]:\n return False\n else:\n return _is_palindrome(input_str, start + 1, end - 1)\n\n # remove spaces and special characters and convert to lower case\n input_string = ''.join(ch for ch in input_string if ch.isalnum()).lower()\n\n return _is_palindrome(input_string, 0, len(input_string) - 1)","def is_palindrome(string):\n\n # Base case: If the string is one character long or fewer, it's a palindrome.\n if len(string) <= 1:\n return True\n \n # Base case: If the first and last characters in the string don't match, it isn't a palindrome.\n if string[0] != string[-1]:\n return False\n \n # At this point, the first and last character in the string are identical.\n # Recursive case: Check if the string remaining after removing the first and last character\n # is a palindrome. If so, this string is a palindrome too.\n return is_palindrome(string[1:-1])","def is_palindrome(x):\n strx = str(x)\n return strx == strx[::-1]\n # chars = [c for c in x] if not is_number(x) else digits(x)\n # for i in range(len(chars) // 2):\n # if chars[i] != chars[len(chars) - i - 1]:\n # return False\n # return True","def is_palindrome(phrase):\n # remove spaces\n phrase = phrase.replace(' ', '').lower()\n\n # reverse phrase\n ans = ''\n for index in range(len(phrase)-1, -1, -1):\n ans += phrase[index]\n\n return True if ans == phrase else False","def __isPalindrome(self, string: str) -> bool:\r\n logger.debug('Checking substring {} for palindrome...'.format(string))\r\n palindrome = False\r\n if string:\r\n palindrome = True\r\n midPoint = int(len(string)/2)\r\n logger.debug('midpoint: {}'.format(midPoint))\r\n for index in range(midPoint+1):\r\n respectiveRightIndex = (len(string) - index - 1)\r\n logger.debug('index: {}, respectiveRightIndex: {}'.format(index, respectiveRightIndex))\r\n if index < respectiveRightIndex:\r\n if respectiveRightIndex < 0:\r\n respectiveRightIndex = 0\r\n if string[index] != string[respectiveRightIndex]:\r\n palindrome = False\r\n\r\n logger.debug('{} is {}'.format(string, 'palindrome' if palindrome else 'not palindrome'))\r\n return palindrome","def is_palindrome(word):\n word = word.replace(\" \", \"\")\n new_word = word.lower()\n\n return new_word == new_word[::-1]","def is_palindrome(n):\n d = digits(n)\n r = int(\"\".join([str(i) for i in d]))\n return n == r","def is_palindrome(s):\n s_copy = s.replace(\" \", \"\")\n n = len(s_copy)\n for i in range(n // 2):\n left = s_copy[i]\n right = s_copy[n - 1 - i]\n if left.upper() != right.upper():\n return False\n return True","def ispalind(num):\n num = list(str(num))\n if num == num[::-1]:\n return True","def is_palindromic(lst):\n return all( lst[i] == lst[-(i+1)] for i in range(len(lst)) )","def is_palindrome(n):\n num = list(str(n))\n h1 = num[:int(len(num)/2)] # first half of palindrome\n if len(num) % 2 == 0:\n h2 = num[int(len(num)/2):] # second half of palindrome\n else:\n h2 = num[int(len(num)/2) + 1:]\n return h1 == list(reversed(h2))","def is_palindrome_ingoring_case_and_non_letter_chars(text):","def is_palindrome(sentence: str) -> bool:\n\n words = extract_words(sentence)\n middle = floor(len(words)/2)\n\n for index in range(middle):\n if words[index].lower() != words[len(words)-index-1].lower():\n return False\n\n return True","def is_permutation_palindrome(str):\n for s in permutations(str): # loop through all permutations of str\n if is_palindrome(s):\n return True # successfully find a palindrome permutation\n return False # reach this, then no possible permutation is palindrome","def palindrom_permutation(string: str):\n string = re.sub(r'\\W+', '', string.lower())\n\n chars = dict()\n for c in string:\n chars[c] = chars[c] + 1 if c in chars else 1\n\n almost_not_okey = False\n for val in chars.values():\n if val % 2 == 1:\n if not almost_not_okey:\n almost_not_okey = True\n else:\n return False\n\n if almost_not_okey:\n return len(string) % 2 == 1\n return True","def check_pal(s):\n counts = df(int)\n len_without_spaces = 0\n # Count all nonspaces\n for c in s:\n if c != ' ':\n counts[c.lower()] += 1\n len_without_spaces += 1\n # Now find out how many chars occur an odd number of times\n odd_chars = 0\n for c in counts:\n if counts[c] % 2 != 0:\n odd_chars += 1\n # If string length is even there must be no odd counts\n if len_without_spaces % 2 == 0 and odd_chars == 0:\n return True\n # If string is odd there must be exactly one odd count\n if len_without_spaces % 2 != 0 and odd_chars == 1:\n return True\n # Else, it's not a palindrome\n return False","def is_palindrome(some_string):\n\n if some_string == \"\":\n return True\n elif len(some_string) == 1:\n return True\n elif some_string[0] != some_string[-1]:\n return False\n else:\n return is_palindrome(some_string[1:-1])","def is_palindrome(the_string: str) -> bool:\n s = the_string.lower()\n # left pointer\n i = 0\n # right pointer\n j = len(s)-1\n # before the left pointer and right pointer meets\n while i < j:\n # if meet white space, the left pointer will move forward without doing anything.\n while i < j and s[i] == \" \":\n i += 1\n # if meet white space, the right pointer will move forward without doing anything.\n while i < j and s[j] == \" \":\n j -= 1\n # test if the char at left pointer equals with char at the right pointer , if yes,\n # left and right pointer move forward to test next pair of chars\n if s[i] == s[j]:\n i += 1\n j -= 1\n # if not, the string is not a palindrome, return False\n else:\n return False\n else:\n return True","def is_palindrome(word):\n word = validator(word)\n\n if word == \"\":\n return True\n\n elif word[0] == word[-1]:\n return is_palindrome(word[1:-1])\n\n return False","def isPalindrome(x):\n # Write the functionality:\n\n if x == str(x)[::-1]:\n return True\n elif x==121:\n return True\n else:\n return False","def part3(string):\n palindrome = True\n for i in range(0, int(len(string)/2) + 1):\n if(string[i] != string[int(len(string))-i-1]):\n palindrome = False\n print(palindrome)","def is_palindrome(num):\n str_num = str(num)\n\n if len(str_num) == 1:\n return True\n elif len(str_num) == 2:\n return str_num[0] == str_num[1]\n\n if str_num[0] == str_num[len(str_num)-1]:\n return is_palindrome(str_num[1:len(str_num)-1])\n else:\n return False","def is_palindrome(word):\n if len(word)>2 and not is_palindrome(middle(word)):\n return False\n else:\n return first(word) == last(word)","def is_palindrome(x):\n \n # Assume negative number is not a palindromic number.\n if x < 0:\n return False\n\n ten_base = 1\n \n # Determine num size with a base of 10\n while x / ten_base >= 10:\n ten_base *= 10\n\n while x > 0:\n left_num, right_num = x / ten_base, x % 10\n if left_num != right_num:\n return False\n \n # Update and prep for next iteration.\n x = (x % ten_base) / 10\n ten_base /= 100\n\n return True","def check_palindrome():\n # Your code goes here...","def check_is_palindrome(mer1, mer2):\n return mer1.find(mer2[::-1]) == 0","def is_palindrome_permutation(string):\n\n letter_to_count = dict()\n\n for letter in string:\n letter_to_count[letter] = letter_to_count.get(letter, 0) + 1\n\n residual = 0\n for count in letter_to_count.values():\n residual += count % 2\n\n # there are can be a single letter with an odd character count when the palindrome is of odd length\n return residual <= 1","def is_palindrome(text):\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\n # change this to call your implementation to verify it passes all tests\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\n # return is_palindrome_iterative(text)\n return is_palindrome_recursive(text)","def is_palin(s):\r\n if s == \"\":\r\n return True\r\n if s[0] == s[-1]:\r\n return is_palin(s[1:-1])\r\n else:\r\n return False","def palindrome_check(num):\n num= str(num)\n len_num= len(num)\n for i in range(len_num/2):\n if num[i] == num[len_num-i-1]:\n ans= True\n else:\n ans= False\n break\n return ans","def has_palindrome(i, start, length):\r\n s = str(i)[start:start+length]\r\n return s[::-1] == s","def check_pal(num):\r\n \r\n num = str(num) #Convert number to string.\r\n \r\n #If a number is a palindrome, rreturn True \r\n if num[0] == num[len(num)-1] and len(num) <= 3:\r\n return True\r\n \r\n #If the first and last digits of a number are equal when its length is > 3,\r\n #strip the end digits away analyse the resulting number.\r\n elif num[0] == num[len(num)-1]:\r\n return check_pal(num[1:len(num)-1])\r\n \r\n #If a number is not a palindrome, return False\r\n else:\r\n return False","def is_palindrome(element):\n if int(element) < 0:\n return False\n if element == element[::-1]:\n return True\n else:\n return False","def is_palindrome(text):\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\n # change this to call your implementation to verify it passes all tests\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\n #return is_palindrome_iterative(text)\n return is_palindrome_recursive(text)","def is_palindrome(text):\n\n # Property of a palindrome:\n # There be a maximum of only one letter that sums to an odd number\n \n char_count = {}\n # edge cases\n # Consider empty text as palindrome\n \n for char in text:\n if char in char_count:\n char_count[char] += 1\n else:\n char_count[char] = 1\n \n odd_count = 0\n for count in char_count.values():\n if count % 2 == 1:\n odd_count += 1\n if odd_count > 1:\n return False\n \n return True","def is_palindrome(text):\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\n # change this to call your implementation to verify it passes all tests\n assert isinstance(text, str)\n # return is_palindrome_iterative(text)\n return is_palindrome_recursive(text)","def check_palindrome(string):\n queue = Deque() # creating object of Deque class\n\n for ch in string:\n queue.insert_rear(ch) # adds all the characters from back\n\n is_equal = True\n\n while queue.size() > 1 and is_equal:\n first = queue.remove_front() # removes the characters from the front of the queue\n last = queue.remove_rear() # removes the characters from the rear of the queue\n if first != last:\n is_equal = False\n\n return is_equal","def has_palindrome_permutation(given_string):\n\n unpaired_characters = set()\n\n for char in given_string:\n if char in unpaired_characters:\n unpaired_characters.remove(char)\n else:\n unpaired_characters.add(char) \n\n return len(unpaired_characters) <= 1","def is_palindrome(text):\n\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\n # return is_palindrome_iterative(text)\n return is_palindrome_recursive(text)","def is_palindrome(n):\n # store locally\n temp = n\n rev = 0\n while n > 0:\n # get digit one by one\n digit = n % 10\n # find reverse number\n rev = rev * 10 + digit\n # divide the number\n n = n // 10\n return temp == rev","def is_palindrome(word):\n if first(word) != last(word):\n print 'not a palindrome'\n return False\n else:\n return is_palindrome(middle(word))","def isPalindrome(S):\n if len(S) == 0:\n return True\n \n if S[0] != S[-1]:\n return False\n \n return isPalindrome(S[1:len(S) - 1])","def is_palindrome(sub):\n for i in range(len(sub)):\n if sub[i] != sub[len(sub) - i - 1]:\n return False\n return True","def is_palindrome(a):\n\tmax = a\n\tmin = 0\n\twhile max > 0:\n\t\tmin = (min * 10 + max % 10)\n\t\tmax /= 10\n\treturn min == a","def is_palindrome3(word):\n\n i = 0\n j = -1\n\n word = word.lower()\n\n if not word.isalnum():\n word = ''.join(character for character in word if character.isalnum())\n\n if word == \"\":\n return True\n\n while len(word) > 1:\n\n if word[i] == word[j]:\n\n i += 1\n j += 1\n\n else:\n return False\n\n return True","def is_palindrome_permutation(input_string):\n input_string = input_string.lower()\n input_string = ''.join(input_string.split())\n\n number_chars = {}\n number_even_chars = 0\n\n for char in input_string:\n if char in number_chars:\n number_chars[char] += 1\n else:\n number_chars[char] = 1\n\n for char in number_chars:\n if number_chars[char] % 2 != 0:\n number_even_chars += 1\n if number_even_chars >= 2:\n return False\n\n return True","def is_palindrome(n):\n v = []\n while n > 0:\n v.append(n % 10)\n n //= 10\n for i in range(len(v)//2):\n if v[i] != v[len(v)-i-1]:\n return False\n return True","def check_palindrome(word):\r\n char_count = {} #char count hash\r\n for char in word:\r\n if char in char_count:\r\n char_count[char] += 1\r\n else:\r\n char_count[char] = 1\r\n odd_count = 0 #counting number of odd nos encountered\r\n for count in char_count.values():\r\n if count % 2 != 0:\r\n odd_count += 1\r\n len_word = len(word)\r\n if len_word % 2 == 0:\r\n if odd_count >= 1:\r\n return False\r\n else:\r\n if odd_count > 1:\r\n return False\r\n return True"],"string":"[\n \"def string_palidrome(word):\\n if word == string_reverse(word):\\n return True\\n else:\\n return False\",\n \"def is_palindrome(string):\\n return\",\n \"def isPalindrome(s):\\r\\n return isPal(toChars(s))\",\n \"def is_palindromic(n: int) -> bool:\\n str_n = str(n)\\n if str_n == str_n[::-1]:\\n return True\\n return False\",\n \"def is_palindrome_v1(s):\\n return reverse(s) == s\",\n \"def isPalindromic(n: int):\\n return str(n) == str(n)[::-1]\",\n \"def check_palindrome():\",\n \"def check_palindrome(s):\\n return s[::-1] == s\",\n \"def is_palindrome(string):\\n return string[::-1] == string\",\n \"def is_palindrome(string):\\n if string == string[::-1]:\\n return True\\n return False\",\n \"def is_palindromic(phrase):\\n\\n val = str(phrase).lower().replace(\\\" \\\", \\\"\\\")\\n if val == val[::-1]: # Reverse order\\n return True\\n else:\\n return False\",\n \"def is_palindrome2(some_string):\\n return reverse_string(some_string) == some_string\",\n \"def check_palindrome(string):\\n palindrome = ''.join(string).lower()\\n if palindrome == palindrome[::-1]:\\n return True\\n else:\\n return False\",\n \"def isPalindrome(self, s: str) -> bool:\\n s = s.translate(str.maketrans('','',string.punctuation)) # drop punctuation\\n s = \\\"\\\".join(s.split()) # drop spaces\\n s = s.lower() # casefold more agressive (ASCII vs UNICODE)\\n\\n return s == s[::-1]\",\n \"def is_palindrome(string):\\n string = string.upper()\\n if reverse(string) == string:\\n #use function reverse() to check if the reverse of the string is same as the original string\\n return True\\n else:\\n return False\",\n \"def is_palindrome(s):\\n return s == s[::-1]\",\n \"def check_palindrome(inp_string):\\n if len(inp_string) <= 2:\\n return False\\n elif inp_string == inp_string[::-1]:\\n return True\\n else:\\n return False\",\n \"def palindrome(string: str) -> Bool:\\n string_lower = string.lower()\\n string_clean =\",\n \"def validPalindrome(self, s: str) -> bool:\\n n = len(s)\\n i = 0\\n j = n - 1\\n while i < j:\\n if s[i] == s[j]:\\n i += 1\\n j -= 1\\n else:\\n # error, for -1, start > end. Indexing is like range\\n # return s[i:j] == s[i:j:-1] or s[i+1:j+1] == s[i+1:j+1:-1]\\n return self.is_palindrome(s[i:j]) or self.is_palindrome(s[i+1:j+1])\\n\\n return True\",\n \"def is_palindrome(s):\\n\\n def to_chars(s):\\n s = s.lower()\\n letters = ''\\n for char in s:\\n if char in 'abcdefghijklmnopqrstuvwxyz':\\n letters += char\\n return letters\\n\\n def is_pal(s):\\n if len(s) <= 1:\\n return True\\n else:\\n return s[0] == s[-1] and is_pal(s[1:-1])\\n\\n return is_pal(to_chars(s))\",\n \"def is_palindrome(string):\\n k, mid = len(string), len(string) // 2\\n # checking even palindromes\\n if k % 2 == 0:\\n return string[:mid] == get_reverse_complement(string[mid:])\\n # checking odd palindromes\\n else:\\n return string[:mid] == get_reverse_complement(string[mid + 1:])\",\n \"def is_palindrome(word: str) -> bool:\\n\\n # Todo\\n return False\",\n \"def checkPalindrome(self, s: str) -> str:\\n # return s[:len(s) // 2] == s[(len(s) + 1) // 2::-1]\\n return s == s[::-1]\",\n \"def is_palindrome(s):\\n rev_str = \\\"\\\"\\n for let in range(1, len(s) + 1):\\n rev_str += s[-let]\\n return rev_str == s\",\n \"def is_palindrome(s):\\n if isinstance(s, str):\\n if s == s[::-1]:\\n return True\\n else:\\n return False\\n if isinstance(s, int):\\n if str(s) == str(s)[::-1]:\\n return True\\n else:\\n return False\\n else:\\n raise AssertionError(\\\"Please enter str\\\")\",\n \"def isPalindrome(self, s: str) -> bool:\\n if not s:\\n return True\\n # process the string\\n s_processed = \\\"\\\"\\n for i in s:\\n if i.isalnum():\\n s_processed += i.lower()\\n # Check if palindrome\\n return s_processed == s_processed[::-1] # String[::-1], O(n)\",\n \"def isPalindrome(string):\\n for i in range(len(string)//2):\\n if string[i] != string[(i*-1)-1]:\\n return False\\n return True\",\n \"def palindrome(string):\\r\\n if len(string) <= 1:\\r\\n return True\\r\\n else:\",\n \"def is_palindrome_v2(s):\\n n = len(s)\\n\\n return s[:n/2] == reverse(s[n-n/2:])\",\n \"def is_palindrome(n):\\n ns = str(n)\\n for i in range(0, len(ns) // 2):\\n if ns[i] != ns[len(ns) - 1 - i]: return False\\n return True\",\n \"def is_palindrome(str):\\n n = len(str)\\n for i in range(n//2): # loop to middle of string str\\n if str[i] != str[-1-i]:\\n return False # find a character doesn't match with its mirror-positioned character\\n return True # reach this, then str is palindrome\",\n \"def is_palindrome(word):\\n if word == word[::-1]:\\n return True\\n else:\\n return False\",\n \"def is_palindrome(string):\\r\\n r_string = string[::-1]\\r\\n cnt = 0\\r\\n while cnt < len(string):\\r\\n if string[cnt] == r_string[cnt]:\\r\\n cnt += 1\\r\\n continue\\r\\n else:\\r\\n return False\\r\\n #cnt += 1\\r\\n return True\",\n \"def palindrome(word):\\n reverse = word[::-1]\\n return word == reverse\",\n \"def is_palindrome(s):\\n i, end = 0, len(s) // 2\\n while i < end:\\n if s[i] != s[len(s) - i - 1]:\\n return False\\n i += 1\\n return True\",\n \"def is_palendrome(my_string):\\n characters = []\\n for char in my_string:\\n characters.append(char)\\n characters.reverse()\\n reversed_string = \\\"\\\".join(characters)\\n if my_string == reversed_string:\\n return True\\n else:\\n return False\",\n \"def is_palindrome(number):\\r\\n str_input = str(number)\\r\\n return str_input == reversed(str_input)\",\n \"def isPalindromes(s):\\n\\n def toChar(s):\\n s= s.lower()\\n letters=''\\n for c in s:\\n if c in \\\"abcdefgh\\\":\\n letters= letters+c\\n return letters\\n\\n def isPal(s):\\n if len(s) <=1:\\n return True\\n else:\\n return s[0]==s[-1] and isPal(s[1:-1])\\n return isPal(toChar(s))\",\n \"def isPalindrome(self, s: str) -> bool:\\n left, right = 0, len(s) - 1\\n while left < right:\\n while left < right and not s[left].isalnum(): # 注意while loop的嵌套\\n left += 1\\n while left < right and not s[right].isalnum():\\n right -= 1\\n if s[left].lower() != s[right].lower():\\n return False\\n left += 1\\n right -= 1\\n return True\",\n \"def palCheck(input_string):\\n\\n # ADD NECESSARY LINES OF CODE SO THAT ALL UNITTESTS PASS\\n\\n d = Deque()\\n for char in input_string:\\n d.addFront(char)\\n\\n while d.size() > 1:\\n firstChar = d.removeRear()\\n lastChar = d.removeFront()\\n if firstChar != lastChar:\\n print(\\\"No, '\\\" + input_string + \\\"', is not a palindrom\\\")\\n return False\\n\\n print(\\\"Yes, '\\\" + input_string + \\\"', is a palindrom!!\\\")\\n return True\",\n \"def is_pal(string):\\n a = reversed(list(string))\\n if list(a) == list(string):\\n return True\\n else:\\n return False\",\n \"def is_palindrome(num_in):\\n if str(num_in) == str(num_in)[::-1]:\\n return True\\n\\n return False\",\n \"def is_pal(n):\\r\\n # Change the number into a string and then a list.\\r\\n as_list_of_chars = list(str(n))\\r\\n # Copy the list and reverse it.\\r\\n reversed_list_of_chars = list(as_list_of_chars)\\r\\n reversed_list_of_chars.reverse()\\r\\n # True if the list of chars is palindromic.\\r\\n return as_list_of_chars == reversed_list_of_chars\",\n \"def is_palindrome(n):\\n return(n == reverse(n))\",\n \"def is_palindrome(num):\\n\\treversed_num = str(num)[::-1]\\n\\tif reversed_num == str(num): return True\\n\\telse: return False\",\n \"def _is_palindrome(input_str, start, end):\\n if start >= end:\\n return True\\n if input_str[start] != input_str[end]:\\n return False\\n else:\\n return _is_palindrome(input_str, start + 1, end - 1)\",\n \"def isPalindrome(word):\\n\\n input_str = IGNORE_NON_ALPHA_CHARACTER.sub(\\\"\\\", str(word)).casefold()\\n return input_str == input_str[::-1]\",\n \"def isPalindrome(n):\\n str_n = str(n)\\n return list(str_n) == list(reversed(str_n))\",\n \"def part3():\\n Input = raw_input('please enter a string:')\\n for i in range(len(Input)):\\n if Input[i] != Input[len(Input)-i-1]:\\n print('It is not a palidrome')\\n break\\n else:\\n i = i + 1\",\n \"def palindrome_integer(string):\\n integers = string.split(\\\" \\\")\\n for integer in integers:\\n reverse = str(int)[::-1]\\n '''Check if palindrome not then return False'''\\n if integer != reverse:\\n return False\\n return True\",\n \"def is_palindrome(word):\\n\\t# The degenerate case is 1 letter or none. We consider these palindromes\\n\\tif len(word) <= 1:\\n\\t\\treturn True\\n\\n\\t# For something to be a palindrome, the first and last letters much match\\n\\t# and the string between them must also be a palindrome\\n\\tif first(word) == last(word) and is_palindrome(middle(word)):\\n\\t\\treturn True\\n\\telse:\\n\\t\\treturn False\",\n \"def is_palindrome_v3(s):\\n i = 0\\n j = len(s)-1\\n\\n while i < j and s[i] == s[j]:\\n i = i + 1\\n j = j -1\\n\\n return j <= i\",\n \"def is_palindrome(input_string):\\n\\n def _is_palindrome(input_str, start, end):\\n \\\"\\\"\\\"Returns whether a string is a palindrome or not\\n using recursion. Assumes string is not empty.\\n \\\"\\\"\\\"\\n if start >= end:\\n return True\\n if input_str[start] != input_str[end]:\\n return False\\n else:\\n return _is_palindrome(input_str, start + 1, end - 1)\\n\\n # remove spaces and special characters and convert to lower case\\n input_string = ''.join(ch for ch in input_string if ch.isalnum()).lower()\\n\\n return _is_palindrome(input_string, 0, len(input_string) - 1)\",\n \"def is_palindrome(string):\\n\\n # Base case: If the string is one character long or fewer, it's a palindrome.\\n if len(string) <= 1:\\n return True\\n \\n # Base case: If the first and last characters in the string don't match, it isn't a palindrome.\\n if string[0] != string[-1]:\\n return False\\n \\n # At this point, the first and last character in the string are identical.\\n # Recursive case: Check if the string remaining after removing the first and last character\\n # is a palindrome. If so, this string is a palindrome too.\\n return is_palindrome(string[1:-1])\",\n \"def is_palindrome(x):\\n strx = str(x)\\n return strx == strx[::-1]\\n # chars = [c for c in x] if not is_number(x) else digits(x)\\n # for i in range(len(chars) // 2):\\n # if chars[i] != chars[len(chars) - i - 1]:\\n # return False\\n # return True\",\n \"def is_palindrome(phrase):\\n # remove spaces\\n phrase = phrase.replace(' ', '').lower()\\n\\n # reverse phrase\\n ans = ''\\n for index in range(len(phrase)-1, -1, -1):\\n ans += phrase[index]\\n\\n return True if ans == phrase else False\",\n \"def __isPalindrome(self, string: str) -> bool:\\r\\n logger.debug('Checking substring {} for palindrome...'.format(string))\\r\\n palindrome = False\\r\\n if string:\\r\\n palindrome = True\\r\\n midPoint = int(len(string)/2)\\r\\n logger.debug('midpoint: {}'.format(midPoint))\\r\\n for index in range(midPoint+1):\\r\\n respectiveRightIndex = (len(string) - index - 1)\\r\\n logger.debug('index: {}, respectiveRightIndex: {}'.format(index, respectiveRightIndex))\\r\\n if index < respectiveRightIndex:\\r\\n if respectiveRightIndex < 0:\\r\\n respectiveRightIndex = 0\\r\\n if string[index] != string[respectiveRightIndex]:\\r\\n palindrome = False\\r\\n\\r\\n logger.debug('{} is {}'.format(string, 'palindrome' if palindrome else 'not palindrome'))\\r\\n return palindrome\",\n \"def is_palindrome(word):\\n word = word.replace(\\\" \\\", \\\"\\\")\\n new_word = word.lower()\\n\\n return new_word == new_word[::-1]\",\n \"def is_palindrome(n):\\n d = digits(n)\\n r = int(\\\"\\\".join([str(i) for i in d]))\\n return n == r\",\n \"def is_palindrome(s):\\n s_copy = s.replace(\\\" \\\", \\\"\\\")\\n n = len(s_copy)\\n for i in range(n // 2):\\n left = s_copy[i]\\n right = s_copy[n - 1 - i]\\n if left.upper() != right.upper():\\n return False\\n return True\",\n \"def ispalind(num):\\n num = list(str(num))\\n if num == num[::-1]:\\n return True\",\n \"def is_palindromic(lst):\\n return all( lst[i] == lst[-(i+1)] for i in range(len(lst)) )\",\n \"def is_palindrome(n):\\n num = list(str(n))\\n h1 = num[:int(len(num)/2)] # first half of palindrome\\n if len(num) % 2 == 0:\\n h2 = num[int(len(num)/2):] # second half of palindrome\\n else:\\n h2 = num[int(len(num)/2) + 1:]\\n return h1 == list(reversed(h2))\",\n \"def is_palindrome_ingoring_case_and_non_letter_chars(text):\",\n \"def is_palindrome(sentence: str) -> bool:\\n\\n words = extract_words(sentence)\\n middle = floor(len(words)/2)\\n\\n for index in range(middle):\\n if words[index].lower() != words[len(words)-index-1].lower():\\n return False\\n\\n return True\",\n \"def is_permutation_palindrome(str):\\n for s in permutations(str): # loop through all permutations of str\\n if is_palindrome(s):\\n return True # successfully find a palindrome permutation\\n return False # reach this, then no possible permutation is palindrome\",\n \"def palindrom_permutation(string: str):\\n string = re.sub(r'\\\\W+', '', string.lower())\\n\\n chars = dict()\\n for c in string:\\n chars[c] = chars[c] + 1 if c in chars else 1\\n\\n almost_not_okey = False\\n for val in chars.values():\\n if val % 2 == 1:\\n if not almost_not_okey:\\n almost_not_okey = True\\n else:\\n return False\\n\\n if almost_not_okey:\\n return len(string) % 2 == 1\\n return True\",\n \"def check_pal(s):\\n counts = df(int)\\n len_without_spaces = 0\\n # Count all nonspaces\\n for c in s:\\n if c != ' ':\\n counts[c.lower()] += 1\\n len_without_spaces += 1\\n # Now find out how many chars occur an odd number of times\\n odd_chars = 0\\n for c in counts:\\n if counts[c] % 2 != 0:\\n odd_chars += 1\\n # If string length is even there must be no odd counts\\n if len_without_spaces % 2 == 0 and odd_chars == 0:\\n return True\\n # If string is odd there must be exactly one odd count\\n if len_without_spaces % 2 != 0 and odd_chars == 1:\\n return True\\n # Else, it's not a palindrome\\n return False\",\n \"def is_palindrome(some_string):\\n\\n if some_string == \\\"\\\":\\n return True\\n elif len(some_string) == 1:\\n return True\\n elif some_string[0] != some_string[-1]:\\n return False\\n else:\\n return is_palindrome(some_string[1:-1])\",\n \"def is_palindrome(the_string: str) -> bool:\\n s = the_string.lower()\\n # left pointer\\n i = 0\\n # right pointer\\n j = len(s)-1\\n # before the left pointer and right pointer meets\\n while i < j:\\n # if meet white space, the left pointer will move forward without doing anything.\\n while i < j and s[i] == \\\" \\\":\\n i += 1\\n # if meet white space, the right pointer will move forward without doing anything.\\n while i < j and s[j] == \\\" \\\":\\n j -= 1\\n # test if the char at left pointer equals with char at the right pointer , if yes,\\n # left and right pointer move forward to test next pair of chars\\n if s[i] == s[j]:\\n i += 1\\n j -= 1\\n # if not, the string is not a palindrome, return False\\n else:\\n return False\\n else:\\n return True\",\n \"def is_palindrome(word):\\n word = validator(word)\\n\\n if word == \\\"\\\":\\n return True\\n\\n elif word[0] == word[-1]:\\n return is_palindrome(word[1:-1])\\n\\n return False\",\n \"def isPalindrome(x):\\n # Write the functionality:\\n\\n if x == str(x)[::-1]:\\n return True\\n elif x==121:\\n return True\\n else:\\n return False\",\n \"def part3(string):\\n palindrome = True\\n for i in range(0, int(len(string)/2) + 1):\\n if(string[i] != string[int(len(string))-i-1]):\\n palindrome = False\\n print(palindrome)\",\n \"def is_palindrome(num):\\n str_num = str(num)\\n\\n if len(str_num) == 1:\\n return True\\n elif len(str_num) == 2:\\n return str_num[0] == str_num[1]\\n\\n if str_num[0] == str_num[len(str_num)-1]:\\n return is_palindrome(str_num[1:len(str_num)-1])\\n else:\\n return False\",\n \"def is_palindrome(word):\\n if len(word)>2 and not is_palindrome(middle(word)):\\n return False\\n else:\\n return first(word) == last(word)\",\n \"def is_palindrome(x):\\n \\n # Assume negative number is not a palindromic number.\\n if x < 0:\\n return False\\n\\n ten_base = 1\\n \\n # Determine num size with a base of 10\\n while x / ten_base >= 10:\\n ten_base *= 10\\n\\n while x > 0:\\n left_num, right_num = x / ten_base, x % 10\\n if left_num != right_num:\\n return False\\n \\n # Update and prep for next iteration.\\n x = (x % ten_base) / 10\\n ten_base /= 100\\n\\n return True\",\n \"def check_palindrome():\\n # Your code goes here...\",\n \"def check_is_palindrome(mer1, mer2):\\n return mer1.find(mer2[::-1]) == 0\",\n \"def is_palindrome_permutation(string):\\n\\n letter_to_count = dict()\\n\\n for letter in string:\\n letter_to_count[letter] = letter_to_count.get(letter, 0) + 1\\n\\n residual = 0\\n for count in letter_to_count.values():\\n residual += count % 2\\n\\n # there are can be a single letter with an odd character count when the palindrome is of odd length\\n return residual <= 1\",\n \"def is_palindrome(text):\\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\\n # change this to call your implementation to verify it passes all tests\\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\\n # return is_palindrome_iterative(text)\\n return is_palindrome_recursive(text)\",\n \"def is_palin(s):\\r\\n if s == \\\"\\\":\\r\\n return True\\r\\n if s[0] == s[-1]:\\r\\n return is_palin(s[1:-1])\\r\\n else:\\r\\n return False\",\n \"def palindrome_check(num):\\n num= str(num)\\n len_num= len(num)\\n for i in range(len_num/2):\\n if num[i] == num[len_num-i-1]:\\n ans= True\\n else:\\n ans= False\\n break\\n return ans\",\n \"def has_palindrome(i, start, length):\\r\\n s = str(i)[start:start+length]\\r\\n return s[::-1] == s\",\n \"def check_pal(num):\\r\\n \\r\\n num = str(num) #Convert number to string.\\r\\n \\r\\n #If a number is a palindrome, rreturn True \\r\\n if num[0] == num[len(num)-1] and len(num) <= 3:\\r\\n return True\\r\\n \\r\\n #If the first and last digits of a number are equal when its length is > 3,\\r\\n #strip the end digits away analyse the resulting number.\\r\\n elif num[0] == num[len(num)-1]:\\r\\n return check_pal(num[1:len(num)-1])\\r\\n \\r\\n #If a number is not a palindrome, return False\\r\\n else:\\r\\n return False\",\n \"def is_palindrome(element):\\n if int(element) < 0:\\n return False\\n if element == element[::-1]:\\n return True\\n else:\\n return False\",\n \"def is_palindrome(text):\\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\\n # change this to call your implementation to verify it passes all tests\\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\\n #return is_palindrome_iterative(text)\\n return is_palindrome_recursive(text)\",\n \"def is_palindrome(text):\\n\\n # Property of a palindrome:\\n # There be a maximum of only one letter that sums to an odd number\\n \\n char_count = {}\\n # edge cases\\n # Consider empty text as palindrome\\n \\n for char in text:\\n if char in char_count:\\n char_count[char] += 1\\n else:\\n char_count[char] = 1\\n \\n odd_count = 0\\n for count in char_count.values():\\n if count % 2 == 1:\\n odd_count += 1\\n if odd_count > 1:\\n return False\\n \\n return True\",\n \"def is_palindrome(text):\\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\\n # change this to call your implementation to verify it passes all tests\\n assert isinstance(text, str)\\n # return is_palindrome_iterative(text)\\n return is_palindrome_recursive(text)\",\n \"def check_palindrome(string):\\n queue = Deque() # creating object of Deque class\\n\\n for ch in string:\\n queue.insert_rear(ch) # adds all the characters from back\\n\\n is_equal = True\\n\\n while queue.size() > 1 and is_equal:\\n first = queue.remove_front() # removes the characters from the front of the queue\\n last = queue.remove_rear() # removes the characters from the rear of the queue\\n if first != last:\\n is_equal = False\\n\\n return is_equal\",\n \"def has_palindrome_permutation(given_string):\\n\\n unpaired_characters = set()\\n\\n for char in given_string:\\n if char in unpaired_characters:\\n unpaired_characters.remove(char)\\n else:\\n unpaired_characters.add(char) \\n\\n return len(unpaired_characters) <= 1\",\n \"def is_palindrome(text):\\n\\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\\n # return is_palindrome_iterative(text)\\n return is_palindrome_recursive(text)\",\n \"def is_palindrome(n):\\n # store locally\\n temp = n\\n rev = 0\\n while n > 0:\\n # get digit one by one\\n digit = n % 10\\n # find reverse number\\n rev = rev * 10 + digit\\n # divide the number\\n n = n // 10\\n return temp == rev\",\n \"def is_palindrome(word):\\n if first(word) != last(word):\\n print 'not a palindrome'\\n return False\\n else:\\n return is_palindrome(middle(word))\",\n \"def isPalindrome(S):\\n if len(S) == 0:\\n return True\\n \\n if S[0] != S[-1]:\\n return False\\n \\n return isPalindrome(S[1:len(S) - 1])\",\n \"def is_palindrome(sub):\\n for i in range(len(sub)):\\n if sub[i] != sub[len(sub) - i - 1]:\\n return False\\n return True\",\n \"def is_palindrome(a):\\n\\tmax = a\\n\\tmin = 0\\n\\twhile max > 0:\\n\\t\\tmin = (min * 10 + max % 10)\\n\\t\\tmax /= 10\\n\\treturn min == a\",\n \"def is_palindrome3(word):\\n\\n i = 0\\n j = -1\\n\\n word = word.lower()\\n\\n if not word.isalnum():\\n word = ''.join(character for character in word if character.isalnum())\\n\\n if word == \\\"\\\":\\n return True\\n\\n while len(word) > 1:\\n\\n if word[i] == word[j]:\\n\\n i += 1\\n j += 1\\n\\n else:\\n return False\\n\\n return True\",\n \"def is_palindrome_permutation(input_string):\\n input_string = input_string.lower()\\n input_string = ''.join(input_string.split())\\n\\n number_chars = {}\\n number_even_chars = 0\\n\\n for char in input_string:\\n if char in number_chars:\\n number_chars[char] += 1\\n else:\\n number_chars[char] = 1\\n\\n for char in number_chars:\\n if number_chars[char] % 2 != 0:\\n number_even_chars += 1\\n if number_even_chars >= 2:\\n return False\\n\\n return True\",\n \"def is_palindrome(n):\\n v = []\\n while n > 0:\\n v.append(n % 10)\\n n //= 10\\n for i in range(len(v)//2):\\n if v[i] != v[len(v)-i-1]:\\n return False\\n return True\",\n \"def check_palindrome(word):\\r\\n char_count = {} #char count hash\\r\\n for char in word:\\r\\n if char in char_count:\\r\\n char_count[char] += 1\\r\\n else:\\r\\n char_count[char] = 1\\r\\n odd_count = 0 #counting number of odd nos encountered\\r\\n for count in char_count.values():\\r\\n if count % 2 != 0:\\r\\n odd_count += 1\\r\\n len_word = len(word)\\r\\n if len_word % 2 == 0:\\r\\n if odd_count >= 1:\\r\\n return False\\r\\n else:\\r\\n if odd_count > 1:\\r\\n return False\\r\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8234154","0.8193637","0.8175128","0.8128422","0.8093423","0.805103","0.8046132","0.801999","0.8012599","0.8002301","0.79903495","0.79647315","0.78919333","0.7880501","0.7864277","0.7843781","0.78298485","0.78054845","0.77765304","0.7763191","0.7761727","0.7741279","0.77262014","0.76966184","0.7687522","0.7682165","0.7629418","0.7609099","0.76034516","0.76021177","0.7587685","0.7571064","0.7565494","0.75313085","0.7525973","0.7520795","0.75190467","0.75130033","0.74718624","0.7457022","0.7455061","0.744508","0.7445079","0.74440646","0.7440362","0.7413015","0.739458","0.7371445","0.73454857","0.73237497","0.7287662","0.7259645","0.7250715","0.7236801","0.7206286","0.71847206","0.7180865","0.71742004","0.71740353","0.7169748","0.7155798","0.7149242","0.71463674","0.7145257","0.7140601","0.7139082","0.71341544","0.7122162","0.7120256","0.7109586","0.71069527","0.7066665","0.7060836","0.7060257","0.70363575","0.7032303","0.70263195","0.6969193","0.6960845","0.6958093","0.6948239","0.69466096","0.69415116","0.6932664","0.6920724","0.69180924","0.6908839","0.69076896","0.6898461","0.6884924","0.68837714","0.6856072","0.68260324","0.6777822","0.67741734","0.6761098","0.6731553","0.6715899","0.6714979","0.6689218"],"string":"[\n \"0.8234154\",\n \"0.8193637\",\n \"0.8175128\",\n \"0.8128422\",\n \"0.8093423\",\n \"0.805103\",\n \"0.8046132\",\n \"0.801999\",\n \"0.8012599\",\n \"0.8002301\",\n \"0.79903495\",\n \"0.79647315\",\n \"0.78919333\",\n \"0.7880501\",\n \"0.7864277\",\n \"0.7843781\",\n \"0.78298485\",\n \"0.78054845\",\n \"0.77765304\",\n \"0.7763191\",\n \"0.7761727\",\n \"0.7741279\",\n \"0.77262014\",\n \"0.76966184\",\n \"0.7687522\",\n \"0.7682165\",\n \"0.7629418\",\n \"0.7609099\",\n \"0.76034516\",\n \"0.76021177\",\n \"0.7587685\",\n \"0.7571064\",\n \"0.7565494\",\n \"0.75313085\",\n \"0.7525973\",\n \"0.7520795\",\n \"0.75190467\",\n \"0.75130033\",\n \"0.74718624\",\n \"0.7457022\",\n \"0.7455061\",\n \"0.744508\",\n \"0.7445079\",\n \"0.74440646\",\n \"0.7440362\",\n \"0.7413015\",\n \"0.739458\",\n \"0.7371445\",\n \"0.73454857\",\n \"0.73237497\",\n \"0.7287662\",\n \"0.7259645\",\n \"0.7250715\",\n \"0.7236801\",\n \"0.7206286\",\n \"0.71847206\",\n \"0.7180865\",\n \"0.71742004\",\n \"0.71740353\",\n \"0.7169748\",\n \"0.7155798\",\n \"0.7149242\",\n \"0.71463674\",\n \"0.7145257\",\n \"0.7140601\",\n \"0.7139082\",\n \"0.71341544\",\n \"0.7122162\",\n \"0.7120256\",\n \"0.7109586\",\n \"0.71069527\",\n \"0.7066665\",\n \"0.7060836\",\n \"0.7060257\",\n \"0.70363575\",\n \"0.7032303\",\n \"0.70263195\",\n \"0.6969193\",\n \"0.6960845\",\n \"0.6958093\",\n \"0.6948239\",\n \"0.69466096\",\n \"0.69415116\",\n \"0.6932664\",\n \"0.6920724\",\n \"0.69180924\",\n \"0.6908839\",\n \"0.69076896\",\n \"0.6898461\",\n \"0.6884924\",\n \"0.68837714\",\n \"0.6856072\",\n \"0.68260324\",\n \"0.6777822\",\n \"0.67741734\",\n \"0.6761098\",\n \"0.6731553\",\n \"0.6715899\",\n \"0.6714979\",\n \"0.6689218\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7539143"},"document_rank":{"kind":"string","value":"33"}}},{"rowIdx":14893,"cells":{"query":{"kind":"string","value":"Functie om huizen die nog over zijn, efficient aan een batterij te koppelen"},"document":{"kind":"string","value":"def fit_house_in_diamond(houses_copy, batteries):\n\n # Output huis die overgebleven is\n output_missing_house = houses_copy[0].get_output()\n\n # Sorteer batterijen resterend capaciteit hoog > laag, en selecteer meest_resterende batterij\n batteries.sort(key=lambda battery: battery.get_remaining(), reverse=True)\n copy_batteries = deepcopy(batteries)\n copy_batteries.pop(0)\n battery_with_most_capacity = batteries[0]\n\n # Blijf loopen, en huizen efficient verwisselen, tot het huis in de batterij past\n for index, battery in enumerate(copy_batteries):\n second_most_battery_capacity = batteries[index + 1]\n capacity_battery_second = second_most_battery_capacity.get_remaining()\n\n # Kijk naar de huizen in de eerst batterij en pak hoogste output\n houses_first_battery = battery_with_most_capacity.get_houses()\n house_most_output = max(houses_first_battery, key=lambda house: house.get_output())\n house_first_index = houses_first_battery.index(house_most_output)\n output_house_most = house_most_output.get_output()\n\n # Kijk naar de huizen in de tweede batterij\n houses_second_battery = second_most_battery_capacity.get_houses()\n second_index_house = None\n second_house_output = 100\n least_remaining_battery_2 = 100\n\n # Pak het huis met een output dat ervoor zorgt dat missende huis past\n for index, house in enumerate(houses_second_battery):\n output_house = house.get_output()\n remaining_battery_2 = capacity_battery_second - (output_house_most - output_house)\n\n # Let hierop dat de eerste en tweede batterij de wissel aankunnen en dat er in één wissel genoeg ruimte is voor het missende huis\n if remaining_battery_2 < least_remaining_battery_2 and remaining_battery_2 >= 0:\n second_house_output = output_house\n second_index_house = index\n least_remaining_battery_2 = remaining_battery_2\n\n houses_first_battery.pop(house_first_index)\n second_house = houses_second_battery.pop(second_index_house)\n houses_first_battery.append(second_house)\n houses_second_battery.append(house_most_output)\n\n if output_missing_house < battery_with_most_capacity.get_remaining():\n houses_first_battery.append(houses_copy.pop(0))\n break"},"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 mezclar_bolsa(self):","def apply(self):","def podziel(self):\n def fraktal(dlugosc, alpha, poziom):\n \"\"\"Metoda wyznaczajaca fraktal.\n\n Metoda ta przyjmuje dlugosc, kat oraz poziom drzewa.\n Na bazie podanych parametrow wylicza fraktal z podanych w zadaniu wzorow.\n Zwraca liste zawierajaca punkX oraz punktY fraktalu.\n \"\"\"\n#obliczanie punktow punktu Abis dla kazdego poziomu galezi\n x = float(self.p2[0] + self.dlugosc * cos(alpha))\n y = float(self.p2[1] + self.dlugosc * sin(alpha))\n return [round(x), round(y)]\n\n#petla przechodzaca po wszystkich poziomach drzewa\n while self.tmp <= self.poziom:\n#obliczanie grubosci, dlugosci galezi oraz kolorowanie jej\n self.grubosc = float((2 * self.grubosc + 1) / 3)\n self.dlugosc = float((2 * self.dlugosc) / 3)\n self.kolor += 6\n\n #sprawdzenie czy kolor nie wyszedl po za skale maksymalnej wartosci\n if self.kolor > 255:\n self.kolor = 255\n\n#rozbicie obliczen na poziom 1 i wyzej\n#Abis jest to punkt prawy dla kazdej galezi\n#B jest to punkt srodkowy dla kazdej galezi\n#C jest to punkt srodkowy dla kazdej galezi\n\n#obliczenia dla pierwszego poziomu\n if self.tmp < 2:\n#obliczenie fraktalu, prawa galaz dla kazdej galezi\n#podstawienie obliczonych wartosci z punktu Abis do pozostalych wedlug podanych wzorow\n Abis = fraktal(self.dlugosc, self.alpha, self.poziom)\n B = [round(self.p2[0]), round(Abis[1])]\n C = [round(-Abis[0] + 2 * self.p2[0]), round(Abis[1])]\n\n#zwiekszenie poziomu drzewa o jeden\n self.tmp += 1\n\n#tutaj nastepuje zwrocenie obiektow typu Branch z nowo obliczonymi wartosciami\n return [Branch(self.p2, Abis, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp),\n Branch(self.p2, B, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp),\n Branch(self.p2, C, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp)]\n#obliczenia poziomow wyzej niz pierwszy\n else:\n#obliczanie kata dla punktu prawego\n self.zetprim = randint(-1, 1) * randint(1, self.s)\n self.beta = self.alpha + self.zetprim\n\n#obliczanie kata dla punktu srodkowego\n self.zetbis = randint(-1, 1) * randint(1, self.s)\n self.gamma = self.alpha + self.zetbis\n\n#obliczanie kata dla punktu lewego\n self.zetter = randint(-1, 1) * randint(1, self.s)\n self.teta = self.alpha + self.zetter\n\n#obliczenie fraktalu, prawa galaz dla kazdej galezi\n#podstawienie obliczonych wartosci z punktu Abis do pozostalych wedlug podanych wzorow\n Abis = fraktal(self.dlugosc, self.beta, self.poziom)\n B = [round(self.p2[0]), round(Abis[1])]\n C = [round(-Abis[0] + 2 * self.p2[0]), round(Abis[1])]\n\n#zwiekszenie poziomu drzewa o jeden\n self.tmp += 1\n\n#tutaj nastepuje zwrocenie obiektow typu Branch z nowo obliczonymi wartosciami\n return [Branch(self.p2, Abis, self.dlugosc, self.grubosc, self.kolor, self.beta, self.tmp),\n Branch(self.p2, B, self.dlugosc, self.grubosc, self.kolor, self.gamma, self.tmp),\n Branch(self.p2, C, self.dlugosc, self.grubosc, self.kolor, self.teta, self.tmp)]","def apply(self) -> None:","def apply(self) -> None:","def puncture(self,x):","def regular(self):","def falcon():","def preberi_pot(ukazi):","def preberi_pot(ukazi):","def preberi_pot(ukazi):","def preberi_pot(ukazi):","def preberi_pot(ukazi):","def degibber(self):","def bloqueio_2(tab,jog):\r\n jog*=-1\r\n return vitoria_1(tab,jog)","def nits(self):","def weight(self):","def transform(self):","def substantiate():","def zyklus(self):\n neu = self.lebendig.copy() # Kopie erstellen\n for zelle in self.lebendig: # Alle lebendigen Zellen durchgehen\n anzahl = self.lebendige_nachbarn(zelle)\n if anzahl < 2 or anzahl > 3: # Vereinsamung oder Überbevölkerung\n neu.remove(zelle) # Stirbt - aus der Liste der Lebendigen entfernen\n # Prüfe alle Nachbarn einer lebendigen Zelle\n # wenn diese genau drei Nachbarn hat, muss sie evtl.\n # lebendig werden\n x, y = zelle\n if self.lebendige_nachbarn((x-1, y+1)) == 3:\n neu.add((x-1, y+1))\n if self.lebendige_nachbarn((x, y+1)) == 3:\n neu.add((x, y+1))\n if self.lebendige_nachbarn((x+1, y+1)) == 3:\n neu.add((x+1, y+1))\n if self.lebendige_nachbarn((x+1, y)) == 3:\n neu.add((x+1, y))\n if self.lebendige_nachbarn((x+1, y-1)) == 3:\n neu.add((x+1, y-1))\n if self.lebendige_nachbarn((x, y-1)) == 3:\n neu.add((x, y-1))\n if self.lebendige_nachbarn((x-1, y-1)) == 3:\n neu.add((x-1, y-1))\n if self.lebendige_nachbarn((x-1, y)) == 3:\n neu.add((x-1, y))\n self.lebendig = neu","def reconChar(PiksList, high):\n position, h=PiksList[0]\n NewPiksList=[]\n \n for piks in PiksList: ##delete all pixels that can not be in tile\n if piks[0]<position+high-1:\n NewPiksList.append(piks)\n \n PiksList=NewPiksList\n \n Char=CharFrame(high,high) ##create new CharFrame object \n for el in PiksList: \n Char.putPixel(el[0]-position,el[1])\n CharScaled=Char\n CharScaled.reScale(30,30) ##skale CharFrame object to the ending size\n return PiksList, CharScaled\n ##this is not testet yet because of not working neuralNetwork\n \"\"\"if CharScaled.getOutput():\n return PiksList, CharScaled\n else:\n prop=[[],[],[]]\n histo=Char.vLinesHistogram()\n for i in range(0, len(histo)):\n if histo[i]<=3:\n prop[histo[i]-1].append(i)\n for proposition in prop:\n proposition.reverse()\n CharPro=copy.deepcopy(Char)\n PiksListPro=copy.deepcopy(PiksList)\n for kolumn in proposition:\n for el in PiksList: #jeśli nie wymyślimy efektywniejszego sposobu\n if el[1]>=proposition:\n CharPro.makeWhite(position-el[0],el[1])\n PiksListPro.remove(el)\n CharProScaled=copy.deepcopy(CharPro)\n CharProScaled.reScale(20,20)\n if CharProScaled.getOutput():\n return PiksListPro, CharProSlaled\n return PiksList, Char # gdyby to nić nie dało by zwrócić cokolwiek\"\"\"","def f(inicio,obj):\n return g(inicio,obj)+h(inicio,obj)","def CL(self):","def fptrunc(self, typ):","def sprawdz(lista):\n # do_usuniecia - lista zawierajaca indeksy pol ktore zostana usuniete z glownej listy\n do_usuniecia = []\n # petla przechodzaca po wartosciach\n for i in range(len(lista) / 2):\n # j - indeks wartosci dla poszczgolnego panstwa\n j = 2 * i + 1\n # k - indeks pod ktorym nie ma wartosci\n k = 0\n # sprawdzanie ktore elementy sa bez wartosci oraz dodawanie ich do listy do usuniecia\n for el in lista[j]:\n if el is None:\n # zastosowanie unikalnosci indeksow\n if not k in do_usuniecia:\n do_usuniecia.append(k)\n\n k += 1\n # sortowanie listy z indeksami do usuniecia w sposob rosnacy\n do_usuniecia.sort()\n # nowalista - lista zawierajaca statystyki dostepne dla wszystkich panstw odpowiednio [Lata],[Wartosc]\n nowalista = []\n for i in range(len(lista)):\n # wartosc - lista zawierajaca poszczegolne dane z glownej listy\n wartosc = []\n # dodawanie wartosci, ktore sa dostepne dla wszystkich panstw do tabeli wartosc\n for j in range(len(lista[i])):\n # zastosowanie unikalnosci indeksow dla ktorych nie ma wartosci\n if not j in do_usuniecia:\n wartosc.append(lista[i][j])\n # dodawanie listy zawierajacej wynik dla poszczegolnych danych\n nowalista.append(wartosc)\n\n return nowalista","def cull(self):","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def transform(self, x):","def verteileKarten(anzahlSpieler):\n pass","def apply_algorithm(self):\n pass","def uvozi_podatke(tabele):\n for t in tabele:\n t.uvozi()","def __reduce__(self): # real signature unknown; restored from __doc__\r\n pass","def T(v,securite):\n to_return = {} #renvoie le dictionnaire {indice du contact (0 -> direct / sinon -> plus ou moins direct) : set({disque})} \n Cv = set(C(v,securite))\n Tv = set(Cv)\n i=0\n xv,yv=l[v][0],l[v][1]\n while Cv != set() and i<5:\n to_return[str(i)]=Cv\n new_Cv = set()\n for j in Cv:\n xj,yj=l[j][0],l[j][1]\n #si j est devant v, on ne le copte pas\n if sqrt((xj-xt)**2+(yj-yt)**2)<sqrt((xv-xt)**2+(yv-yt)**2):\n continue\n new_Cv= new_Cv.__or__(C(j,securite).__sub__(Tv.__or__(set(j).__or__({v}))))\n Tv = Tv.__or__(new_Cv)\n Cv = new_Cv\n i+=1\n return to_return","def firstFunction(self):","def exo2():","def w2f(sents,i,j,filename,freq):\n w = sents[i][j][0] #current word\n pos = sents[i][j][1] #POS of current word\n f = [ \n 'bias', #non-contextual feature \n 'w=' + w, #current word \n 'w.istitle=%s' % w.istitle(), #first letter - capitalized\n 'pos=' + pos, # POS tag\n 'w.intitle=%s' % contained_in_title(w, filename), # w matches title\n 'w.lowtitle=%s' % lower_in_title(w, filename), # w lower matches title\n 'w.freq=%s' % frequency(w, freq), # freq of w \n 'w.stopword=%s' % stop_word(w), # # stop word\n ]\n \n # previous word features\n if j>0:\n pw = sents[i][j-1][0] #previous word\n ppos = sents[i][j-1][1] #POS of previous word\n f.extend([ \n 'pw=' + pw, # previous word \n 'pw.istitle=%s' % pw.istitle(), #first letter - capitalized\n 'ppos=' + ppos, # POS tag\n 'pw.intitle=%s' % contained_in_title(pw, filename), # w matches title\n 'pw.lowtitle=%s' % lower_in_title(pw,filename), # w lower matches title\n 'pw.freq=%s' % frequency(pw, freq), # freq of w\n 'pw.stopword=%s' % stop_word(w), # # stop word\n ])\n else: \n f.append('BOS') #first word of a sentence\n\n # next word features\n if j<len(sents[i])-1:\n nw = sents[i][j+1][0] #next word\n npos = sents[i][j+1][1] #POS of next word\n f.extend([ \n 'nw=' + nw, # previous word\n 'nw.istitle=%s' % nw.istitle(), #first letter - capitalized\n 'npos=' + npos, #POS tag\n 'nw.intitle=%s' % contained_in_title(nw, filename), # w matches title\n 'nw.lowtitle=%s' % lower_in_title(nw,filename), # w lower matches title\n 'nw.freq=%s' % frequency(nw, freq), # freq of w\n 'nw.stopword=%s' % stop_word(w), # # stop word\n ])\n else: \n f.append('EOS') # last word of a sentence\n\n #if j>1: ...\n #if j<len(sents[i])-2: ...\n #if j>0 and j<len(sents[i])-1: ...\n return f","def exercise_b2_53():\r\n pass","def pulp_smash():","def apply(self):\n pass","def apply(self):\n pass","def __init__(self, cls_filt: dict[str: np.ndarray], transfs: dict[str: np.ndarray], inoise: dict[str: np.ndarray or float]):\n job = []\n for f in transfs:\n if f + f in cls_filt:\n job.append(f)\n\n for i, f in enumerate(job):\n assert (f + f) in cls_filt\n assert f in transfs\n assert f + f in inoise or f in inoise\n if f in inoise:\n inoise[f + f] = inoise[f]\n for g in job: # always want f + g in the keys\n if g != f:\n for cl in [cls_filt, inoise]:\n if g + f in cl:\n cl[f + g] = cl[g + f]\n if f + g in cl:\n cl[g + f] = cl[f + g]\n\n lmaxs_wted = {field: len(transfs[field]) - 1 for field in job}\n lmaxs_ivfs = {field: len(transfs[field]) - 1 for field in job}\n\n maps_labels = job # input map labels\n alms_labels = job # filtered solutions labels\n\n lmax = np.max([lmax for lmax in lmaxs_ivfs.values()])\n transfs_i = {lab: np.zeros(lmax + 1) for lab in transfs}\n for lab in transfs:\n ls = np.where(transfs[lab] != 0)\n transfs_i[lab][ls] = 1. / transfs[lab][ls]\n\n self.job = job\n self.maps_labels = maps_labels\n\n self.cls = cls_filt\n self.inoise = inoise\n\n\n self.lmax_wted = lmaxs_wted\n self.lmax_ivfs = lmaxs_ivfs\n self.mmax_ivfs = lmaxs_ivfs # not necessary\n\n self.nalm = len(job)\n\n self.transfs = transfs\n self.transfs_i = transfs_i\n\n\n print('OpFilt setup')\n for f in self.job:\n print(f + ' lmax %s' % lmaxs_ivfs[f])\n print('expected input maps: ' + ' '.join(maps_labels))\n print('filtered alms : ' + ' '.join(alms_labels))\n\n self._fal = None\n self._fal = self._build_fal()","def _decorate ( name = _name ) :\n import LoKiCore.decorators as _LoKiCore\n _mcp = 'const LHCb::MCParticle*'\n _mcv = 'const LHCb::MCVertex*'\n #_vp = std.vector( _mcp )\n #_vv = std.vector( _mcv )\n #_vd = std.vector( 'double' )\n _vp = 'std::vector<const LHCb::MCParticle*>' ## std.vector( _mcp )\n _vv = 'std::vector<const LHCb::MCVertex*>' ## std.vector( _mcv )\n _vd = 'std::vector<double>' ## std.vector( 'double' )\n #\n \n # MCParticle -> double\n \n _decorated = _LoKiCore.getAndDecorateFunctions ( \n name , ## modulr name \n LoKi.Functor (_mcp,'double') , ## the base\n LoKi.Dicts.FunCalls (LHCb.MCParticle) , ## call-traits\n LoKi.Dicts.FuncOps (_mcp,_mcp) ) ## operators&operations\n \n # MCVertex -> double\n \n _decorated != _LoKiCore.getAndDecorateFunctions ( \n name , ## moduel name \n LoKi.Functor (_mcv,'double') , ## the base\n LoKi.Dicts.FunCalls (LHCb.MCVertex) , ## call-traits\n LoKi.Dicts.FuncOps (_mcv,_mcv) ) ## operators&operations\n \n # MCParticle -> bool\n \n _decorated != _LoKiCore.getAndDecoratePredicates (\n name , ## module name \n LoKi.Functor (_mcp,bool) , ## the base\n LoKi.Dicts.CutCalls (LHCb.MCParticle) , ## call-traits\n LoKi.Dicts.CutsOps (_mcp,_mcp) ) ## operators&operations\n \n # MCVertex -> bool\n \n _decorated != _LoKiCore.getAndDecoratePredicates (\n name , ## module name \n LoKi.Functor (_mcv,bool) , ## the base\n LoKi.Dicts.CutCalls (LHCb.MCVertex) , ## call-traits\n LoKi.Dicts.CutsOps (_mcv,_mcv) ) ## operators&operations\n\n ## functional part:\n \n # vector<T> -> vector<double>\n \n _decorated |= _LoKiCore.getAndDecorateMaps (\n name , ## moduel name \n LoKi.Functor (_vp,_vd) , ## the base\n LoKi.Dicts.MapsOps(_mcp) ) ## call-traits\n _decorated |= _LoKiCore.getAndDecorateMaps (\n name , ## moduel name \n LoKi.Functor (_vv,_vd) , ## the base\n LoKi.Dicts.MapsOps(_mcv) ) ## call-traits\n\n # vector<T> -> vector<T>\n\n _decorated |= _LoKiCore.getAndDecoratePipes (\n name , ## module name \n LoKi.Functor (_vp,_vp) , ## the base\n LoKi.Dicts.PipeOps(_mcp,_mcp) ) ## call-traits\n _decorated |= _LoKiCore.getAndDecoratePipes (\n name , ## module name \n LoKi.Functor (_vv,_vv) , ## the base\n LoKi.Dicts.PipeOps(_mcv,_mcv) ) ## call-traits\n\n # vector<T> -> double\n \n _decorated |= _LoKiCore.getAndDecorateFunVals ( \n name , ## module name \n LoKi.Functor (_vp,'double') , ## the base\n LoKi.Dicts.FunValOps(_mcp) ) ## call-traits\n _decorated |= _LoKiCore.getAndDecorateFunVals ( \n name , ## module name \n LoKi.Functor (_vv,'double') , ## the base\n LoKi.Dicts.FunValOps(_mcv) ) ## call-traits\n\n # vector<T> -> bool\n\n _decorated |= _LoKiCore.getAndDecorateCutVals ( \n name , ## module name \n LoKi.Functor (_vp,bool) , ## the base\n LoKi.Dicts.CutValOps(_mcp) ) ## call-traits\n _decorated |= _LoKiCore.getAndDecorateCutVals ( \n name , ## module name \n LoKi.Functor (_vv,bool) , ## the base\n LoKi.Dicts.CutValOps(_mcv) ) ## call-traits\n\n #sources : void -> vector<T>\n\n _decorated |= _LoKiCore.getAndDecorateSources ( \n name , ## module name \n LoKi.Functor ('void',_vp) , ## the base\n LoKi.Dicts.SourceOps(_mcp,_mcp) ) ## call-traits\n _decorated |= _LoKiCore.getAndDecorateSources ( \n name , ## module name \n LoKi.Functor ('void',_vv) , ## the base\n LoKi.Dicts.SourceOps(_mcv,_mcv) ) ## call-traits\n\n\n ## primitive voids:\n\n _decorated |= _LoKiCore.getAndDecoratePrimitiveVoids ( name ) \n \n \n ## decorate pids (Comparison with strings, integers and ParticleID objects:\n for t in ( MCID , MCABSID ) :\n t = type ( t ) \n _LoKiCore.decoratePID ( t , LoKi.Dicts.PIDOps ( t ) )\n _decorated.add ( t )\n\n \n return _decorated","def output_fluent(fil,nodes,elems):\n print \"Nodal coordinates\"\n print nodes\n print \"Element connectivity\"\n print elems\n faces = array(Tet4.faces) # Turning faces into an array is important !\n print \"Tetraeder faces\"\n print faces\n elf = elems.take(faces,axis=1)\n # Remark: the shorter syntax elems[faces] takes its elements along the\n # axis 0. Then we would need to transpose() first (and probably\n # swap axes again later)\n print \"The faces of the elements:\"\n print elf\n # We need a copy to sort the nodes (sorting is done in-place)\n elfs = elf.copy()\n elfs.sort(axis=2) \n print \"The faces with sorted nodes:\"\n print elfs\n magic = elems.max()+1\n print \"Magic number = %d\" % magic\n code = encode(elfs[:,:,0],elfs[:,:,1],elfs[:,:,2],magic)\n # Remark how nice the encode function works on the whole array\n print \"Encoded faces:\"\n print code\n code = code.ravel()\n print code\n print \"Just A Check:\"\n print \"Element 5 face 2 is %s \" % elf[5,2]\n print \"Element 5 face 2 is %s \" % list(decode(code[4*5+2],magic))\n srt = code.argsort()\n print srt\n print code[srt]\n # Now shipout the faces in this order, removing the doubles\n j = -1 \n for i in srt:\n if j < 0: # no predecessor (or predecessor already shipped)\n j = i\n else:\n e1,f1 = j/4, j%4\n if code[i] == code[j]:\n e2,f2 = i/4, i%4\n j = -1\n else:\n e2 = -1\n j = i\n print \"Face %s belongs to el %s and el %s\" % ( elf[e1,f1], e2, e1 )","def reemplaza_tildes(palabra):","def batalhar(i, j):\n if (i.medabot.ataque > j.medabot.defesa or j.medabot.ataque > i.medabot.defesa) and i.medabot.ataque - j.medabot.defesa != j.medabot.ataque - i.medabot.defesa:\n if i.medabot.ataque - j.medabot.defesa > j.medabot.ataque - i.medabot.defesa:\n troca_peca(i, j)\n return i\n else:\n troca_peca(j, i)\n return j\n elif i.habilidade != j.habilidade:\n if i.habilidade > j.habilidade:\n troca_peca(i, j)\n return i\n else:\n troca_peca(j, i)\n return j\n else:\n if i.ID < j.ID:\n troca_peca(i, j)\n return i\n else:\n troca_peca(j, i)\n return j","def fit_covid_function(self):\r\n return","def lower_covers(self, x):","def exercise_b2_52():\r\n pass","def transform():","def _optimise(self):\n pass","def canto_oposto_6(tab, jog):\r\n jog*=-1\r\n if obter_linha(tab,1)[0]==jog and eh_posicao_livre(tab,9):\r\n return 9\r\n if obter_linha(tab,1)[2]==jog and eh_posicao_livre(tab,7):\r\n return 7\r\n if obter_linha(tab,3)[0]==jog and eh_posicao_livre(tab,3):\r\n return 3\r\n if obter_linha(tab,3)[2]==jog and eh_posicao_livre(tab,1):\r\n return 1","def fG(self):\n pass","def cliquer_sur_unité(self):","def appears(self):","def exercise_b2_26():\r\n pass","def __invert__(self):\n return self.wc","def __invert__(self):\n return self.wc","def remove(func):","def g():","def fama (self , diccionario):\n\n decoracion_list = []\n for key , value in diccionario.items():\n a=[]\n a.append(key)\n a.append(value)\n decoracion_list.append (a)\n\n paredes_list = decoracion_list [0:3]\n suelo_list = decoracion_list [3:6]\n reforma_list = decoracion_list [6:]\n\n paredes = 1\n suelo = 1\n reforma = 1\n\n for i in range (len(paredes_list)):\n if paredes_list [i][1] == 1 :\n paredes = i+2 \n\n for i in range (len(suelo_list)):\n if suelo_list [i][1] == 1 :\n suelo = i+2\n\n for i in range (len(reforma_list)):\n if reforma_list [i][1] == 1 :\n reforma = i+2\n\n modificador_fama = 0\n\n if paredes >= 4 and suelo >= 4 and reforma >= 4 :\n modificador_fama = 45\n\n elif paredes >= 3 and suelo >= 3 and reforma >= 3 :\n modificador_fama = 33 \n\n elif paredes >= 2 and suelo >= 2 and reforma >= 2 :\n modificador_fama = 12\n\n fama = (10*paredes)+(10*suelo)+(10*reforma) + modificador_fama + kasino.modificador_fama\n\n \"\"\" FORMULA FAMA : Con esta formula se calcula la fama, que dependera de la decoracion e influira en los visitantes \n Se puede usar modificador_fama para calibrar el juego o añadir niveles de dificulad \"\"\"\n \n return fama , paredes , suelo , reforma","def othersn(ax):","def exercise_b2_69():\r\n pass","def function(self):\n raise NotImplementedError","def MINET(self):","def fn():","def o_wo_per_head(self):\n assert self.ff % self.heads == 0\n # fuse ff->e and projection layer of self-attention\n return (self.ff // (self.heads-self.padded_heads)) + self.qkv","def u2fkn( self , u ):","def testBeliefs2sk(self):","def _perturbInPlaceHard(self):\n die","def aestrella(inicio,obj):\n nodos_abiertos=[inicio]\n nodos_cerrados=[]\n lista1=[]\n for cel in nodos_abiertos:\n lista1.append(cel.costo)\n m=min(lista1)\n for j in nodos_abiertos:\n j.set_gscore(g(inicio,j))\n j.set_hscore(h(j,obj))\n j.set_fscore(f(inicio,obj))\n if j.fscore==m:\n if j==obj:\n print'terminado'\n nodos_cerrados.append(j)\n else:\n nodos_abiertos.append(j)\n for k in j.vecinos:\n if k in nodos_cerrados :\n gk=k.gscore\n gk1=k.get_gscore()\n if gk1<=gk:\n k.set_gscore=gk1\n j=k\n else:\n pass\n elif k in nodos_abiertos:\n gk=k.gscore\n gk1=k.get_gscore\n if gk1<=gk:\n k.set_gscore=gk1\n j=k\n else:\n pass\n \n else:\n nodos_abiertos.append(k)\n k.set_gscore()\n else:\n pass\n ruta=[] \n for u in nodos_cerrados:\n lnc=len(nodos_cerrados)\n for v in range(lnc):\n ruta.insert(v,nodos_cerrados[lnc-v])\n return ruta","def pareto_frontier(cmrf,featlist) :\n\tQ = []\n\ttaboodict = {}\n\tnStates = len(featlist)\n\tfeat1,feat2 = featlist\n\tEaxa,Xa = cmrf.decode(feat1)\n\tEbxb,Xb = cmrf.decode(feat2)\n\tif Xa == Xb : \n\t\treturn [Xa],[(Eaxa,Ebxb)]\n\tEaxb = cmrf.score(Xb,feat1)\n\tEbxa = cmrf.score(Xa,feat2)\n\tQ.append((Xa,Xb))\n\tfrontier,frontier_energy = [],[]\n\tfrontier.extend([Xa,Xb])\n\tfrontier_energy.extend([(Eaxa,Ebxa),(Eaxb,Ebxb)])\n\ttaboodict[(Eaxa,Ebxa)] = 1;\n\ttaboodict[(Eaxb,Ebxb)] = 1;\n\twhile len(Q) > 0 :\n\t\t### Optimize \n\t\tXa,Xb = Q[0]\n\t\tQ = Q[1:] # Dequeue\n\t\tEaxb = cmrf.score(Xb,feat1)\n\t\tEbxa = cmrf.score(Xa,feat2)\t\n\t\tEaxa = cmrf.score(Xa,feat1)\n\t\tEbxb = cmrf.score(Xb,feat2)\t\n\t\tm = (Ebxa - Ebxb)/(Eaxa-Eaxb)\n\t\tif m > 0 : \n\t\t\t#stop()\n\t\t\tsys.stderr.write(\"### WARNING : Slope > 0. Cvxhull failed\")\n\t\t\treturn frontier,frontier_energy\n\t\tthetaa = -m/(1-m)\n\t\tthetab = 1/(1-m)\n\t\ttmrf = TMRF(cmrf,[thetaa,thetab],[feat1,feat2])\n\t\tXab = tmrf.decode()[1]\n\t\tEaxab = cmrf.score(Xab,feat1)\n\t\tEbxab = cmrf.score(Xab,feat2)\n\t\tif Xab != Xa and Xab != Xb and \\\n\t\t\tnot taboodict.has_key((Eaxab,Ebxab)) :\n\t\t\t# Check almost equal condition\n\t\t\tif any(map(lambda(x):almost_eq(Eaxab,x[0] or \\\n\t\t\t\talmost_eq(Ebxab,x[1])),taboodict.keys())) : \n\t\t\t\tcontinue\n\t\t\t\t\t\n\t\t\tfrontier.append(Xab)\n\t\t\tfrontier_energy.append((Eaxab,Ebxab))\n\t\t\ttaboodict[(Eaxab,Ebxab)]=1\n\t\t\tQ.extend([(Xa,Xab),(Xab,Xb)])\n\t# Calculate energy of frontier elements\t\n\treturn frontier,frontier_energy","def solvate(self):\n\n pass","def piku():\n pass","def ustvari(self):\n raise NotImplementedError","def _cce(func, s, sf, bl, bu, mask, icall, maxn, alpha, beta, maxit, printit):\n\n \"\"\"\n List of local variables\n sb(.) = the best point of the simplex\n sw(.) = the worst point of the simplex\n w2(.) = the second worst point of the simplex\n fw = function value of the worst point\n ce(.) = the centroid of the simplex excluding wo\n snew(.) = new point generated from the simplex\n iviol = flag indicating if constraints are violated\n = 1 , yes\n = 0 , no\n \"\"\"\n # Assign the best and worst points:\n sb = s[0,:]\n fb = sf[0]\n sw = s[-1,:]\n fw = sf[-1]\n\n # Compute the centroid of the simplex excluding the worst point:\n ce = np.mean(s[:-1,:],axis=0)\n\n # Attempt a reflection point\n snew = ce + alpha*(ce-sw)\n snew = np.where(mask, snew, sb) # sb should have initial params at mask==False\n\n # Check if is outside the bounds:\n ibound = 0\n # s1 = snew-bl\n # idx = (s1<0).nonzero()\n # if idx[0].size != 0: ibound = 1\n if np.ma.any(np.ma.array(snew-bl, mask=~mask) < 0.): ibound = 1\n\n # s1 = bu-snew\n # idx = (s1<0).nonzero()\n # if idx[0].size != 0: ibound = 2\n if np.ma.any(np.ma.array(bu-snew, mask=~mask) < 0.): ibound = 2\n\n if ibound >= 1:\n snew = _SampleInputMatrix(1,bl,bu,distname='randomUniform')[0]\n snew = np.where(mask, snew, sb)\n\n fuc = func(snew)\n fnew = -fuc if maxit else fuc\n icall += 1\n if printit==1: print(' i, f, X: ', icall, fnew, snew)\n\n # Reflection failed; now attempt a contraction point:\n if fnew > fw:\n snew = sw + beta*(ce-sw)\n snew = np.where(mask, snew, sb)\n fuc = func(snew)\n fnew = -fuc if maxit else fuc\n icall += 1\n if printit==1: print(' i, f, X: ', icall, fnew, snew)\n\n # Both reflection and contraction have failed, attempt a random point;\n if fnew > fw:\n snew = _SampleInputMatrix(1,bl,bu,distname='randomUniform')[0]\n snew = np.where(mask, snew, sb)\n fuc = func(snew)\n fnew = -fuc if maxit else fuc\n icall += 1\n if printit==1: print(' i, f, X: ', icall, fnew, snew)\n\n # end of _cce\n return snew, fnew, icall","def bic(self, X):\n raise NotImplementedError","def bloqueio_de_bifurcacao_4(tab,jog): \r\n if len(bifurcacao_3(tab,-1*jog)) == 1 :\r\n return bifurcacao_3(tab,-1*jog)[0]\r\n else:\r\n for i in range(1,4):\r\n if obter_coluna(tab,i).count(jog)==1:\r\n col = obter_coluna(tab,i)\r\n for j in range(3):\r\n if col[j]==0:\r\n pos1=3*j+i\r\n newtab = marcar_posicao(tab, jog, pos1)\r\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\r\n return pos1\r\n \r\n if obter_linha(tab,i).count(jog)==1:\r\n linha = obter_linha(tab,i)\r\n for j in range(3):\r\n if linha[j]==0:\r\n pos1=j+1+3*(i-1)\r\n newtab = marcar_posicao(tab, jog, pos1)\r\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\r\n return pos1\r\n \r\n if i < 3 and obter_diagonal(tab,i).count(jog)==1:\r\n diagonal = obter_diagonal(tab,i)\r\n for j in range(3):\r\n if i==1:\r\n if diagonal[j]==0:\r\n pos1=4*j+i\r\n newtab = marcar_posicao(tab, jog, pos1)\r\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\r\n return pos1\r\n else:\r\n if diagonal[j]==0:\r\n pos1=7-2*j\r\n newtab = marcar_posicao(tab, jog, pos1)\r\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\r\n return pos1","def camino_minimo_bfs(grafo, origen):\n visitados = set()\n padres = {}\n orden = {}\n cola = collections.deque()\n\n visitados.add(origen)\n padres[origen] = None\n orden[origen] = 0\n cola.append(origen)\n\n while cola:\n v = cola.popleft()\n for w in grafo.adyacentes(v):\n if w not in visitados:\n visitados.add(w)\n padres[w] = v\n orden[w] = orden[v] + 1\n cola.append(w)\n\n return orden ,padres","def fptosi(self, typ):","def logits_placeholder(self):","def joueCoup(position,coup):\n nouvelle_pos = clonePosition(position) # on duplique pour ne pas modifier l'original\n n = nouvelle_pos['taille']\n trait = nouvelle_pos['trait']\n # on transforme coup en indice\n if trait == 'SUD':\n indice_depart = coup-1\n else:\n indice_depart = 2*n-coup\n # retrait des graines de la case de depart\n nbGraines = nouvelle_pos['tablier'][indice_depart]\n nouvelle_pos['tablier'][indice_depart] = 0\n # on seme les graines dans les cases a partir de celle de depart\n indice_courant = indice_depart\n while nbGraines > 0:\n indice_courant = (indice_courant + 1) % (2*n)\n if (indice_courant != indice_depart): # si ce n'est pas la case de depart\n nouvelle_pos['tablier'][indice_courant] += 1 # on seme une graine\n nbGraines -= 1\n # la case d'arrivee est dans le camp ennemi ?\n if (trait == 'NORD'):\n estChezEnnemi = (indice_courant < n)\n else:\n estChezEnnemi = (indice_courant >= n)\n # realisation des prises eventuelles\n while estChezEnnemi and (nouvelle_pos['tablier'][indice_courant] in range(2,4)):\n nouvelle_pos['graines'][trait] += nouvelle_pos['tablier'][indice_courant]\n nouvelle_pos['tablier'][indice_courant] = 0\n indice_courant = (indice_courant - 1) % (2*n)\n if (trait == 'NORD'):\n estChezEnnemi = (indice_courant < n)\n else:\n estChezEnnemi = (indice_courant >= n)\n # mise a jour du camp au trait\n if trait == 'SUD':\n nouvelle_pos['trait'] = 'NORD'\n else:\n nouvelle_pos['trait'] = 'SUD'\n return nouvelle_pos","def map():","def map(z):\n pass","def soul(f):\n\n def is_soul(self, *args, **kwargs):\n # TODO\n return f(self, *args, **kwargs)\n\n return is_soul","def hilfe(self):\n sZweieck_hilfe(3)","def f1_score(self):","def mask(self):","def exercise_b2_82():\r\n pass","def exercise_b2_70():\r\n pass","def sitofp(self, typ):","def exercise_b2_106():\r\n pass","def preprocess(self):","def hadamard_function(self, qubits):\n\n for qubit in qubits:\n H | qubit","def afficher(dico):\n return dico","def feat():\n pass","def pohyb(seznam_tahu, seznam_ovoce, tah,radky, sloupce):\n\n x= seznam_tahu [len(seznam_tahu)-1][0] # [x,y] souradnice noveho tahu\n y= seznam_tahu [len(seznam_tahu)-1][1]\n\n if tah == \"s\": #sever\n y -= 1\n elif tah == \"j\": #jih\n y += 1\n elif tah == \"v\": #vychod\n x += 1\n elif tah == \"z\": #zapad\n x -= 1\n else:\n print(\"Zadal jsi spatne pismeno.\" )\n return()\n\n if x<0 or x>sloupce-1 or y<0 or y>radky-1: #tah mimo pole\n print(\"Tah neni mozny, je mimo hraci pole. Opakuj tah.\")\n elif [x,y] in seznam_tahu: #jiz obsazene policko hadem\n print(\"Tah neni mozny, had uz na nem je. Opakuj tah.\")\n elif [x,y] in seznam_ovoce: #policko s ovocem, vola se funkce snez\n snez (seznam_ovoce, seznam_tahu,[x,y],radky, sloupce)\n else:\n seznam_tahu.append([x,y]) #tah na volne policko, prida se tah a odebere posledni bod\n seznam_tahu.pop(0)","def fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw):\n\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\n\tTocwf=Vk*Ck*Dk/GDen\n\treturn Tocwf"],"string":"[\n \"def mezclar_bolsa(self):\",\n \"def apply(self):\",\n \"def podziel(self):\\n def fraktal(dlugosc, alpha, poziom):\\n \\\"\\\"\\\"Metoda wyznaczajaca fraktal.\\n\\n Metoda ta przyjmuje dlugosc, kat oraz poziom drzewa.\\n Na bazie podanych parametrow wylicza fraktal z podanych w zadaniu wzorow.\\n Zwraca liste zawierajaca punkX oraz punktY fraktalu.\\n \\\"\\\"\\\"\\n#obliczanie punktow punktu Abis dla kazdego poziomu galezi\\n x = float(self.p2[0] + self.dlugosc * cos(alpha))\\n y = float(self.p2[1] + self.dlugosc * sin(alpha))\\n return [round(x), round(y)]\\n\\n#petla przechodzaca po wszystkich poziomach drzewa\\n while self.tmp <= self.poziom:\\n#obliczanie grubosci, dlugosci galezi oraz kolorowanie jej\\n self.grubosc = float((2 * self.grubosc + 1) / 3)\\n self.dlugosc = float((2 * self.dlugosc) / 3)\\n self.kolor += 6\\n\\n #sprawdzenie czy kolor nie wyszedl po za skale maksymalnej wartosci\\n if self.kolor > 255:\\n self.kolor = 255\\n\\n#rozbicie obliczen na poziom 1 i wyzej\\n#Abis jest to punkt prawy dla kazdej galezi\\n#B jest to punkt srodkowy dla kazdej galezi\\n#C jest to punkt srodkowy dla kazdej galezi\\n\\n#obliczenia dla pierwszego poziomu\\n if self.tmp < 2:\\n#obliczenie fraktalu, prawa galaz dla kazdej galezi\\n#podstawienie obliczonych wartosci z punktu Abis do pozostalych wedlug podanych wzorow\\n Abis = fraktal(self.dlugosc, self.alpha, self.poziom)\\n B = [round(self.p2[0]), round(Abis[1])]\\n C = [round(-Abis[0] + 2 * self.p2[0]), round(Abis[1])]\\n\\n#zwiekszenie poziomu drzewa o jeden\\n self.tmp += 1\\n\\n#tutaj nastepuje zwrocenie obiektow typu Branch z nowo obliczonymi wartosciami\\n return [Branch(self.p2, Abis, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp),\\n Branch(self.p2, B, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp),\\n Branch(self.p2, C, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp)]\\n#obliczenia poziomow wyzej niz pierwszy\\n else:\\n#obliczanie kata dla punktu prawego\\n self.zetprim = randint(-1, 1) * randint(1, self.s)\\n self.beta = self.alpha + self.zetprim\\n\\n#obliczanie kata dla punktu srodkowego\\n self.zetbis = randint(-1, 1) * randint(1, self.s)\\n self.gamma = self.alpha + self.zetbis\\n\\n#obliczanie kata dla punktu lewego\\n self.zetter = randint(-1, 1) * randint(1, self.s)\\n self.teta = self.alpha + self.zetter\\n\\n#obliczenie fraktalu, prawa galaz dla kazdej galezi\\n#podstawienie obliczonych wartosci z punktu Abis do pozostalych wedlug podanych wzorow\\n Abis = fraktal(self.dlugosc, self.beta, self.poziom)\\n B = [round(self.p2[0]), round(Abis[1])]\\n C = [round(-Abis[0] + 2 * self.p2[0]), round(Abis[1])]\\n\\n#zwiekszenie poziomu drzewa o jeden\\n self.tmp += 1\\n\\n#tutaj nastepuje zwrocenie obiektow typu Branch z nowo obliczonymi wartosciami\\n return [Branch(self.p2, Abis, self.dlugosc, self.grubosc, self.kolor, self.beta, self.tmp),\\n Branch(self.p2, B, self.dlugosc, self.grubosc, self.kolor, self.gamma, self.tmp),\\n Branch(self.p2, C, self.dlugosc, self.grubosc, self.kolor, self.teta, self.tmp)]\",\n \"def apply(self) -> None:\",\n \"def apply(self) -> None:\",\n \"def puncture(self,x):\",\n \"def regular(self):\",\n \"def falcon():\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def degibber(self):\",\n \"def bloqueio_2(tab,jog):\\r\\n jog*=-1\\r\\n return vitoria_1(tab,jog)\",\n \"def nits(self):\",\n \"def weight(self):\",\n \"def transform(self):\",\n \"def substantiate():\",\n \"def zyklus(self):\\n neu = self.lebendig.copy() # Kopie erstellen\\n for zelle in self.lebendig: # Alle lebendigen Zellen durchgehen\\n anzahl = self.lebendige_nachbarn(zelle)\\n if anzahl < 2 or anzahl > 3: # Vereinsamung oder Überbevölkerung\\n neu.remove(zelle) # Stirbt - aus der Liste der Lebendigen entfernen\\n # Prüfe alle Nachbarn einer lebendigen Zelle\\n # wenn diese genau drei Nachbarn hat, muss sie evtl.\\n # lebendig werden\\n x, y = zelle\\n if self.lebendige_nachbarn((x-1, y+1)) == 3:\\n neu.add((x-1, y+1))\\n if self.lebendige_nachbarn((x, y+1)) == 3:\\n neu.add((x, y+1))\\n if self.lebendige_nachbarn((x+1, y+1)) == 3:\\n neu.add((x+1, y+1))\\n if self.lebendige_nachbarn((x+1, y)) == 3:\\n neu.add((x+1, y))\\n if self.lebendige_nachbarn((x+1, y-1)) == 3:\\n neu.add((x+1, y-1))\\n if self.lebendige_nachbarn((x, y-1)) == 3:\\n neu.add((x, y-1))\\n if self.lebendige_nachbarn((x-1, y-1)) == 3:\\n neu.add((x-1, y-1))\\n if self.lebendige_nachbarn((x-1, y)) == 3:\\n neu.add((x-1, y))\\n self.lebendig = neu\",\n \"def reconChar(PiksList, high):\\n position, h=PiksList[0]\\n NewPiksList=[]\\n \\n for piks in PiksList: ##delete all pixels that can not be in tile\\n if piks[0]<position+high-1:\\n NewPiksList.append(piks)\\n \\n PiksList=NewPiksList\\n \\n Char=CharFrame(high,high) ##create new CharFrame object \\n for el in PiksList: \\n Char.putPixel(el[0]-position,el[1])\\n CharScaled=Char\\n CharScaled.reScale(30,30) ##skale CharFrame object to the ending size\\n return PiksList, CharScaled\\n ##this is not testet yet because of not working neuralNetwork\\n \\\"\\\"\\\"if CharScaled.getOutput():\\n return PiksList, CharScaled\\n else:\\n prop=[[],[],[]]\\n histo=Char.vLinesHistogram()\\n for i in range(0, len(histo)):\\n if histo[i]<=3:\\n prop[histo[i]-1].append(i)\\n for proposition in prop:\\n proposition.reverse()\\n CharPro=copy.deepcopy(Char)\\n PiksListPro=copy.deepcopy(PiksList)\\n for kolumn in proposition:\\n for el in PiksList: #jeśli nie wymyślimy efektywniejszego sposobu\\n if el[1]>=proposition:\\n CharPro.makeWhite(position-el[0],el[1])\\n PiksListPro.remove(el)\\n CharProScaled=copy.deepcopy(CharPro)\\n CharProScaled.reScale(20,20)\\n if CharProScaled.getOutput():\\n return PiksListPro, CharProSlaled\\n return PiksList, Char # gdyby to nić nie dało by zwrócić cokolwiek\\\"\\\"\\\"\",\n \"def f(inicio,obj):\\n return g(inicio,obj)+h(inicio,obj)\",\n \"def CL(self):\",\n \"def fptrunc(self, typ):\",\n \"def sprawdz(lista):\\n # do_usuniecia - lista zawierajaca indeksy pol ktore zostana usuniete z glownej listy\\n do_usuniecia = []\\n # petla przechodzaca po wartosciach\\n for i in range(len(lista) / 2):\\n # j - indeks wartosci dla poszczgolnego panstwa\\n j = 2 * i + 1\\n # k - indeks pod ktorym nie ma wartosci\\n k = 0\\n # sprawdzanie ktore elementy sa bez wartosci oraz dodawanie ich do listy do usuniecia\\n for el in lista[j]:\\n if el is None:\\n # zastosowanie unikalnosci indeksow\\n if not k in do_usuniecia:\\n do_usuniecia.append(k)\\n\\n k += 1\\n # sortowanie listy z indeksami do usuniecia w sposob rosnacy\\n do_usuniecia.sort()\\n # nowalista - lista zawierajaca statystyki dostepne dla wszystkich panstw odpowiednio [Lata],[Wartosc]\\n nowalista = []\\n for i in range(len(lista)):\\n # wartosc - lista zawierajaca poszczegolne dane z glownej listy\\n wartosc = []\\n # dodawanie wartosci, ktore sa dostepne dla wszystkich panstw do tabeli wartosc\\n for j in range(len(lista[i])):\\n # zastosowanie unikalnosci indeksow dla ktorych nie ma wartosci\\n if not j in do_usuniecia:\\n wartosc.append(lista[i][j])\\n # dodawanie listy zawierajacej wynik dla poszczegolnych danych\\n nowalista.append(wartosc)\\n\\n return nowalista\",\n \"def cull(self):\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def transform(self, x):\",\n \"def verteileKarten(anzahlSpieler):\\n pass\",\n \"def apply_algorithm(self):\\n pass\",\n \"def uvozi_podatke(tabele):\\n for t in tabele:\\n t.uvozi()\",\n \"def __reduce__(self): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def T(v,securite):\\n to_return = {} #renvoie le dictionnaire {indice du contact (0 -> direct / sinon -> plus ou moins direct) : set({disque})} \\n Cv = set(C(v,securite))\\n Tv = set(Cv)\\n i=0\\n xv,yv=l[v][0],l[v][1]\\n while Cv != set() and i<5:\\n to_return[str(i)]=Cv\\n new_Cv = set()\\n for j in Cv:\\n xj,yj=l[j][0],l[j][1]\\n #si j est devant v, on ne le copte pas\\n if sqrt((xj-xt)**2+(yj-yt)**2)<sqrt((xv-xt)**2+(yv-yt)**2):\\n continue\\n new_Cv= new_Cv.__or__(C(j,securite).__sub__(Tv.__or__(set(j).__or__({v}))))\\n Tv = Tv.__or__(new_Cv)\\n Cv = new_Cv\\n i+=1\\n return to_return\",\n \"def firstFunction(self):\",\n \"def exo2():\",\n \"def w2f(sents,i,j,filename,freq):\\n w = sents[i][j][0] #current word\\n pos = sents[i][j][1] #POS of current word\\n f = [ \\n 'bias', #non-contextual feature \\n 'w=' + w, #current word \\n 'w.istitle=%s' % w.istitle(), #first letter - capitalized\\n 'pos=' + pos, # POS tag\\n 'w.intitle=%s' % contained_in_title(w, filename), # w matches title\\n 'w.lowtitle=%s' % lower_in_title(w, filename), # w lower matches title\\n 'w.freq=%s' % frequency(w, freq), # freq of w \\n 'w.stopword=%s' % stop_word(w), # # stop word\\n ]\\n \\n # previous word features\\n if j>0:\\n pw = sents[i][j-1][0] #previous word\\n ppos = sents[i][j-1][1] #POS of previous word\\n f.extend([ \\n 'pw=' + pw, # previous word \\n 'pw.istitle=%s' % pw.istitle(), #first letter - capitalized\\n 'ppos=' + ppos, # POS tag\\n 'pw.intitle=%s' % contained_in_title(pw, filename), # w matches title\\n 'pw.lowtitle=%s' % lower_in_title(pw,filename), # w lower matches title\\n 'pw.freq=%s' % frequency(pw, freq), # freq of w\\n 'pw.stopword=%s' % stop_word(w), # # stop word\\n ])\\n else: \\n f.append('BOS') #first word of a sentence\\n\\n # next word features\\n if j<len(sents[i])-1:\\n nw = sents[i][j+1][0] #next word\\n npos = sents[i][j+1][1] #POS of next word\\n f.extend([ \\n 'nw=' + nw, # previous word\\n 'nw.istitle=%s' % nw.istitle(), #first letter - capitalized\\n 'npos=' + npos, #POS tag\\n 'nw.intitle=%s' % contained_in_title(nw, filename), # w matches title\\n 'nw.lowtitle=%s' % lower_in_title(nw,filename), # w lower matches title\\n 'nw.freq=%s' % frequency(nw, freq), # freq of w\\n 'nw.stopword=%s' % stop_word(w), # # stop word\\n ])\\n else: \\n f.append('EOS') # last word of a sentence\\n\\n #if j>1: ...\\n #if j<len(sents[i])-2: ...\\n #if j>0 and j<len(sents[i])-1: ...\\n return f\",\n \"def exercise_b2_53():\\r\\n pass\",\n \"def pulp_smash():\",\n \"def apply(self):\\n pass\",\n \"def apply(self):\\n pass\",\n \"def __init__(self, cls_filt: dict[str: np.ndarray], transfs: dict[str: np.ndarray], inoise: dict[str: np.ndarray or float]):\\n job = []\\n for f in transfs:\\n if f + f in cls_filt:\\n job.append(f)\\n\\n for i, f in enumerate(job):\\n assert (f + f) in cls_filt\\n assert f in transfs\\n assert f + f in inoise or f in inoise\\n if f in inoise:\\n inoise[f + f] = inoise[f]\\n for g in job: # always want f + g in the keys\\n if g != f:\\n for cl in [cls_filt, inoise]:\\n if g + f in cl:\\n cl[f + g] = cl[g + f]\\n if f + g in cl:\\n cl[g + f] = cl[f + g]\\n\\n lmaxs_wted = {field: len(transfs[field]) - 1 for field in job}\\n lmaxs_ivfs = {field: len(transfs[field]) - 1 for field in job}\\n\\n maps_labels = job # input map labels\\n alms_labels = job # filtered solutions labels\\n\\n lmax = np.max([lmax for lmax in lmaxs_ivfs.values()])\\n transfs_i = {lab: np.zeros(lmax + 1) for lab in transfs}\\n for lab in transfs:\\n ls = np.where(transfs[lab] != 0)\\n transfs_i[lab][ls] = 1. / transfs[lab][ls]\\n\\n self.job = job\\n self.maps_labels = maps_labels\\n\\n self.cls = cls_filt\\n self.inoise = inoise\\n\\n\\n self.lmax_wted = lmaxs_wted\\n self.lmax_ivfs = lmaxs_ivfs\\n self.mmax_ivfs = lmaxs_ivfs # not necessary\\n\\n self.nalm = len(job)\\n\\n self.transfs = transfs\\n self.transfs_i = transfs_i\\n\\n\\n print('OpFilt setup')\\n for f in self.job:\\n print(f + ' lmax %s' % lmaxs_ivfs[f])\\n print('expected input maps: ' + ' '.join(maps_labels))\\n print('filtered alms : ' + ' '.join(alms_labels))\\n\\n self._fal = None\\n self._fal = self._build_fal()\",\n \"def _decorate ( name = _name ) :\\n import LoKiCore.decorators as _LoKiCore\\n _mcp = 'const LHCb::MCParticle*'\\n _mcv = 'const LHCb::MCVertex*'\\n #_vp = std.vector( _mcp )\\n #_vv = std.vector( _mcv )\\n #_vd = std.vector( 'double' )\\n _vp = 'std::vector<const LHCb::MCParticle*>' ## std.vector( _mcp )\\n _vv = 'std::vector<const LHCb::MCVertex*>' ## std.vector( _mcv )\\n _vd = 'std::vector<double>' ## std.vector( 'double' )\\n #\\n \\n # MCParticle -> double\\n \\n _decorated = _LoKiCore.getAndDecorateFunctions ( \\n name , ## modulr name \\n LoKi.Functor (_mcp,'double') , ## the base\\n LoKi.Dicts.FunCalls (LHCb.MCParticle) , ## call-traits\\n LoKi.Dicts.FuncOps (_mcp,_mcp) ) ## operators&operations\\n \\n # MCVertex -> double\\n \\n _decorated != _LoKiCore.getAndDecorateFunctions ( \\n name , ## moduel name \\n LoKi.Functor (_mcv,'double') , ## the base\\n LoKi.Dicts.FunCalls (LHCb.MCVertex) , ## call-traits\\n LoKi.Dicts.FuncOps (_mcv,_mcv) ) ## operators&operations\\n \\n # MCParticle -> bool\\n \\n _decorated != _LoKiCore.getAndDecoratePredicates (\\n name , ## module name \\n LoKi.Functor (_mcp,bool) , ## the base\\n LoKi.Dicts.CutCalls (LHCb.MCParticle) , ## call-traits\\n LoKi.Dicts.CutsOps (_mcp,_mcp) ) ## operators&operations\\n \\n # MCVertex -> bool\\n \\n _decorated != _LoKiCore.getAndDecoratePredicates (\\n name , ## module name \\n LoKi.Functor (_mcv,bool) , ## the base\\n LoKi.Dicts.CutCalls (LHCb.MCVertex) , ## call-traits\\n LoKi.Dicts.CutsOps (_mcv,_mcv) ) ## operators&operations\\n\\n ## functional part:\\n \\n # vector<T> -> vector<double>\\n \\n _decorated |= _LoKiCore.getAndDecorateMaps (\\n name , ## moduel name \\n LoKi.Functor (_vp,_vd) , ## the base\\n LoKi.Dicts.MapsOps(_mcp) ) ## call-traits\\n _decorated |= _LoKiCore.getAndDecorateMaps (\\n name , ## moduel name \\n LoKi.Functor (_vv,_vd) , ## the base\\n LoKi.Dicts.MapsOps(_mcv) ) ## call-traits\\n\\n # vector<T> -> vector<T>\\n\\n _decorated |= _LoKiCore.getAndDecoratePipes (\\n name , ## module name \\n LoKi.Functor (_vp,_vp) , ## the base\\n LoKi.Dicts.PipeOps(_mcp,_mcp) ) ## call-traits\\n _decorated |= _LoKiCore.getAndDecoratePipes (\\n name , ## module name \\n LoKi.Functor (_vv,_vv) , ## the base\\n LoKi.Dicts.PipeOps(_mcv,_mcv) ) ## call-traits\\n\\n # vector<T> -> double\\n \\n _decorated |= _LoKiCore.getAndDecorateFunVals ( \\n name , ## module name \\n LoKi.Functor (_vp,'double') , ## the base\\n LoKi.Dicts.FunValOps(_mcp) ) ## call-traits\\n _decorated |= _LoKiCore.getAndDecorateFunVals ( \\n name , ## module name \\n LoKi.Functor (_vv,'double') , ## the base\\n LoKi.Dicts.FunValOps(_mcv) ) ## call-traits\\n\\n # vector<T> -> bool\\n\\n _decorated |= _LoKiCore.getAndDecorateCutVals ( \\n name , ## module name \\n LoKi.Functor (_vp,bool) , ## the base\\n LoKi.Dicts.CutValOps(_mcp) ) ## call-traits\\n _decorated |= _LoKiCore.getAndDecorateCutVals ( \\n name , ## module name \\n LoKi.Functor (_vv,bool) , ## the base\\n LoKi.Dicts.CutValOps(_mcv) ) ## call-traits\\n\\n #sources : void -> vector<T>\\n\\n _decorated |= _LoKiCore.getAndDecorateSources ( \\n name , ## module name \\n LoKi.Functor ('void',_vp) , ## the base\\n LoKi.Dicts.SourceOps(_mcp,_mcp) ) ## call-traits\\n _decorated |= _LoKiCore.getAndDecorateSources ( \\n name , ## module name \\n LoKi.Functor ('void',_vv) , ## the base\\n LoKi.Dicts.SourceOps(_mcv,_mcv) ) ## call-traits\\n\\n\\n ## primitive voids:\\n\\n _decorated |= _LoKiCore.getAndDecoratePrimitiveVoids ( name ) \\n \\n \\n ## decorate pids (Comparison with strings, integers and ParticleID objects:\\n for t in ( MCID , MCABSID ) :\\n t = type ( t ) \\n _LoKiCore.decoratePID ( t , LoKi.Dicts.PIDOps ( t ) )\\n _decorated.add ( t )\\n\\n \\n return _decorated\",\n \"def output_fluent(fil,nodes,elems):\\n print \\\"Nodal coordinates\\\"\\n print nodes\\n print \\\"Element connectivity\\\"\\n print elems\\n faces = array(Tet4.faces) # Turning faces into an array is important !\\n print \\\"Tetraeder faces\\\"\\n print faces\\n elf = elems.take(faces,axis=1)\\n # Remark: the shorter syntax elems[faces] takes its elements along the\\n # axis 0. Then we would need to transpose() first (and probably\\n # swap axes again later)\\n print \\\"The faces of the elements:\\\"\\n print elf\\n # We need a copy to sort the nodes (sorting is done in-place)\\n elfs = elf.copy()\\n elfs.sort(axis=2) \\n print \\\"The faces with sorted nodes:\\\"\\n print elfs\\n magic = elems.max()+1\\n print \\\"Magic number = %d\\\" % magic\\n code = encode(elfs[:,:,0],elfs[:,:,1],elfs[:,:,2],magic)\\n # Remark how nice the encode function works on the whole array\\n print \\\"Encoded faces:\\\"\\n print code\\n code = code.ravel()\\n print code\\n print \\\"Just A Check:\\\"\\n print \\\"Element 5 face 2 is %s \\\" % elf[5,2]\\n print \\\"Element 5 face 2 is %s \\\" % list(decode(code[4*5+2],magic))\\n srt = code.argsort()\\n print srt\\n print code[srt]\\n # Now shipout the faces in this order, removing the doubles\\n j = -1 \\n for i in srt:\\n if j < 0: # no predecessor (or predecessor already shipped)\\n j = i\\n else:\\n e1,f1 = j/4, j%4\\n if code[i] == code[j]:\\n e2,f2 = i/4, i%4\\n j = -1\\n else:\\n e2 = -1\\n j = i\\n print \\\"Face %s belongs to el %s and el %s\\\" % ( elf[e1,f1], e2, e1 )\",\n \"def reemplaza_tildes(palabra):\",\n \"def batalhar(i, j):\\n if (i.medabot.ataque > j.medabot.defesa or j.medabot.ataque > i.medabot.defesa) and i.medabot.ataque - j.medabot.defesa != j.medabot.ataque - i.medabot.defesa:\\n if i.medabot.ataque - j.medabot.defesa > j.medabot.ataque - i.medabot.defesa:\\n troca_peca(i, j)\\n return i\\n else:\\n troca_peca(j, i)\\n return j\\n elif i.habilidade != j.habilidade:\\n if i.habilidade > j.habilidade:\\n troca_peca(i, j)\\n return i\\n else:\\n troca_peca(j, i)\\n return j\\n else:\\n if i.ID < j.ID:\\n troca_peca(i, j)\\n return i\\n else:\\n troca_peca(j, i)\\n return j\",\n \"def fit_covid_function(self):\\r\\n return\",\n \"def lower_covers(self, x):\",\n \"def exercise_b2_52():\\r\\n pass\",\n \"def transform():\",\n \"def _optimise(self):\\n pass\",\n \"def canto_oposto_6(tab, jog):\\r\\n jog*=-1\\r\\n if obter_linha(tab,1)[0]==jog and eh_posicao_livre(tab,9):\\r\\n return 9\\r\\n if obter_linha(tab,1)[2]==jog and eh_posicao_livre(tab,7):\\r\\n return 7\\r\\n if obter_linha(tab,3)[0]==jog and eh_posicao_livre(tab,3):\\r\\n return 3\\r\\n if obter_linha(tab,3)[2]==jog and eh_posicao_livre(tab,1):\\r\\n return 1\",\n \"def fG(self):\\n pass\",\n \"def cliquer_sur_unité(self):\",\n \"def appears(self):\",\n \"def exercise_b2_26():\\r\\n pass\",\n \"def __invert__(self):\\n return self.wc\",\n \"def __invert__(self):\\n return self.wc\",\n \"def remove(func):\",\n \"def g():\",\n \"def fama (self , diccionario):\\n\\n decoracion_list = []\\n for key , value in diccionario.items():\\n a=[]\\n a.append(key)\\n a.append(value)\\n decoracion_list.append (a)\\n\\n paredes_list = decoracion_list [0:3]\\n suelo_list = decoracion_list [3:6]\\n reforma_list = decoracion_list [6:]\\n\\n paredes = 1\\n suelo = 1\\n reforma = 1\\n\\n for i in range (len(paredes_list)):\\n if paredes_list [i][1] == 1 :\\n paredes = i+2 \\n\\n for i in range (len(suelo_list)):\\n if suelo_list [i][1] == 1 :\\n suelo = i+2\\n\\n for i in range (len(reforma_list)):\\n if reforma_list [i][1] == 1 :\\n reforma = i+2\\n\\n modificador_fama = 0\\n\\n if paredes >= 4 and suelo >= 4 and reforma >= 4 :\\n modificador_fama = 45\\n\\n elif paredes >= 3 and suelo >= 3 and reforma >= 3 :\\n modificador_fama = 33 \\n\\n elif paredes >= 2 and suelo >= 2 and reforma >= 2 :\\n modificador_fama = 12\\n\\n fama = (10*paredes)+(10*suelo)+(10*reforma) + modificador_fama + kasino.modificador_fama\\n\\n \\\"\\\"\\\" FORMULA FAMA : Con esta formula se calcula la fama, que dependera de la decoracion e influira en los visitantes \\n Se puede usar modificador_fama para calibrar el juego o añadir niveles de dificulad \\\"\\\"\\\"\\n \\n return fama , paredes , suelo , reforma\",\n \"def othersn(ax):\",\n \"def exercise_b2_69():\\r\\n pass\",\n \"def function(self):\\n raise NotImplementedError\",\n \"def MINET(self):\",\n \"def fn():\",\n \"def o_wo_per_head(self):\\n assert self.ff % self.heads == 0\\n # fuse ff->e and projection layer of self-attention\\n return (self.ff // (self.heads-self.padded_heads)) + self.qkv\",\n \"def u2fkn( self , u ):\",\n \"def testBeliefs2sk(self):\",\n \"def _perturbInPlaceHard(self):\\n die\",\n \"def aestrella(inicio,obj):\\n nodos_abiertos=[inicio]\\n nodos_cerrados=[]\\n lista1=[]\\n for cel in nodos_abiertos:\\n lista1.append(cel.costo)\\n m=min(lista1)\\n for j in nodos_abiertos:\\n j.set_gscore(g(inicio,j))\\n j.set_hscore(h(j,obj))\\n j.set_fscore(f(inicio,obj))\\n if j.fscore==m:\\n if j==obj:\\n print'terminado'\\n nodos_cerrados.append(j)\\n else:\\n nodos_abiertos.append(j)\\n for k in j.vecinos:\\n if k in nodos_cerrados :\\n gk=k.gscore\\n gk1=k.get_gscore()\\n if gk1<=gk:\\n k.set_gscore=gk1\\n j=k\\n else:\\n pass\\n elif k in nodos_abiertos:\\n gk=k.gscore\\n gk1=k.get_gscore\\n if gk1<=gk:\\n k.set_gscore=gk1\\n j=k\\n else:\\n pass\\n \\n else:\\n nodos_abiertos.append(k)\\n k.set_gscore()\\n else:\\n pass\\n ruta=[] \\n for u in nodos_cerrados:\\n lnc=len(nodos_cerrados)\\n for v in range(lnc):\\n ruta.insert(v,nodos_cerrados[lnc-v])\\n return ruta\",\n \"def pareto_frontier(cmrf,featlist) :\\n\\tQ = []\\n\\ttaboodict = {}\\n\\tnStates = len(featlist)\\n\\tfeat1,feat2 = featlist\\n\\tEaxa,Xa = cmrf.decode(feat1)\\n\\tEbxb,Xb = cmrf.decode(feat2)\\n\\tif Xa == Xb : \\n\\t\\treturn [Xa],[(Eaxa,Ebxb)]\\n\\tEaxb = cmrf.score(Xb,feat1)\\n\\tEbxa = cmrf.score(Xa,feat2)\\n\\tQ.append((Xa,Xb))\\n\\tfrontier,frontier_energy = [],[]\\n\\tfrontier.extend([Xa,Xb])\\n\\tfrontier_energy.extend([(Eaxa,Ebxa),(Eaxb,Ebxb)])\\n\\ttaboodict[(Eaxa,Ebxa)] = 1;\\n\\ttaboodict[(Eaxb,Ebxb)] = 1;\\n\\twhile len(Q) > 0 :\\n\\t\\t### Optimize \\n\\t\\tXa,Xb = Q[0]\\n\\t\\tQ = Q[1:] # Dequeue\\n\\t\\tEaxb = cmrf.score(Xb,feat1)\\n\\t\\tEbxa = cmrf.score(Xa,feat2)\\t\\n\\t\\tEaxa = cmrf.score(Xa,feat1)\\n\\t\\tEbxb = cmrf.score(Xb,feat2)\\t\\n\\t\\tm = (Ebxa - Ebxb)/(Eaxa-Eaxb)\\n\\t\\tif m > 0 : \\n\\t\\t\\t#stop()\\n\\t\\t\\tsys.stderr.write(\\\"### WARNING : Slope > 0. Cvxhull failed\\\")\\n\\t\\t\\treturn frontier,frontier_energy\\n\\t\\tthetaa = -m/(1-m)\\n\\t\\tthetab = 1/(1-m)\\n\\t\\ttmrf = TMRF(cmrf,[thetaa,thetab],[feat1,feat2])\\n\\t\\tXab = tmrf.decode()[1]\\n\\t\\tEaxab = cmrf.score(Xab,feat1)\\n\\t\\tEbxab = cmrf.score(Xab,feat2)\\n\\t\\tif Xab != Xa and Xab != Xb and \\\\\\n\\t\\t\\tnot taboodict.has_key((Eaxab,Ebxab)) :\\n\\t\\t\\t# Check almost equal condition\\n\\t\\t\\tif any(map(lambda(x):almost_eq(Eaxab,x[0] or \\\\\\n\\t\\t\\t\\talmost_eq(Ebxab,x[1])),taboodict.keys())) : \\n\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tfrontier.append(Xab)\\n\\t\\t\\tfrontier_energy.append((Eaxab,Ebxab))\\n\\t\\t\\ttaboodict[(Eaxab,Ebxab)]=1\\n\\t\\t\\tQ.extend([(Xa,Xab),(Xab,Xb)])\\n\\t# Calculate energy of frontier elements\\t\\n\\treturn frontier,frontier_energy\",\n \"def solvate(self):\\n\\n pass\",\n \"def piku():\\n pass\",\n \"def ustvari(self):\\n raise NotImplementedError\",\n \"def _cce(func, s, sf, bl, bu, mask, icall, maxn, alpha, beta, maxit, printit):\\n\\n \\\"\\\"\\\"\\n List of local variables\\n sb(.) = the best point of the simplex\\n sw(.) = the worst point of the simplex\\n w2(.) = the second worst point of the simplex\\n fw = function value of the worst point\\n ce(.) = the centroid of the simplex excluding wo\\n snew(.) = new point generated from the simplex\\n iviol = flag indicating if constraints are violated\\n = 1 , yes\\n = 0 , no\\n \\\"\\\"\\\"\\n # Assign the best and worst points:\\n sb = s[0,:]\\n fb = sf[0]\\n sw = s[-1,:]\\n fw = sf[-1]\\n\\n # Compute the centroid of the simplex excluding the worst point:\\n ce = np.mean(s[:-1,:],axis=0)\\n\\n # Attempt a reflection point\\n snew = ce + alpha*(ce-sw)\\n snew = np.where(mask, snew, sb) # sb should have initial params at mask==False\\n\\n # Check if is outside the bounds:\\n ibound = 0\\n # s1 = snew-bl\\n # idx = (s1<0).nonzero()\\n # if idx[0].size != 0: ibound = 1\\n if np.ma.any(np.ma.array(snew-bl, mask=~mask) < 0.): ibound = 1\\n\\n # s1 = bu-snew\\n # idx = (s1<0).nonzero()\\n # if idx[0].size != 0: ibound = 2\\n if np.ma.any(np.ma.array(bu-snew, mask=~mask) < 0.): ibound = 2\\n\\n if ibound >= 1:\\n snew = _SampleInputMatrix(1,bl,bu,distname='randomUniform')[0]\\n snew = np.where(mask, snew, sb)\\n\\n fuc = func(snew)\\n fnew = -fuc if maxit else fuc\\n icall += 1\\n if printit==1: print(' i, f, X: ', icall, fnew, snew)\\n\\n # Reflection failed; now attempt a contraction point:\\n if fnew > fw:\\n snew = sw + beta*(ce-sw)\\n snew = np.where(mask, snew, sb)\\n fuc = func(snew)\\n fnew = -fuc if maxit else fuc\\n icall += 1\\n if printit==1: print(' i, f, X: ', icall, fnew, snew)\\n\\n # Both reflection and contraction have failed, attempt a random point;\\n if fnew > fw:\\n snew = _SampleInputMatrix(1,bl,bu,distname='randomUniform')[0]\\n snew = np.where(mask, snew, sb)\\n fuc = func(snew)\\n fnew = -fuc if maxit else fuc\\n icall += 1\\n if printit==1: print(' i, f, X: ', icall, fnew, snew)\\n\\n # end of _cce\\n return snew, fnew, icall\",\n \"def bic(self, X):\\n raise NotImplementedError\",\n \"def bloqueio_de_bifurcacao_4(tab,jog): \\r\\n if len(bifurcacao_3(tab,-1*jog)) == 1 :\\r\\n return bifurcacao_3(tab,-1*jog)[0]\\r\\n else:\\r\\n for i in range(1,4):\\r\\n if obter_coluna(tab,i).count(jog)==1:\\r\\n col = obter_coluna(tab,i)\\r\\n for j in range(3):\\r\\n if col[j]==0:\\r\\n pos1=3*j+i\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n \\r\\n if obter_linha(tab,i).count(jog)==1:\\r\\n linha = obter_linha(tab,i)\\r\\n for j in range(3):\\r\\n if linha[j]==0:\\r\\n pos1=j+1+3*(i-1)\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n \\r\\n if i < 3 and obter_diagonal(tab,i).count(jog)==1:\\r\\n diagonal = obter_diagonal(tab,i)\\r\\n for j in range(3):\\r\\n if i==1:\\r\\n if diagonal[j]==0:\\r\\n pos1=4*j+i\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n else:\\r\\n if diagonal[j]==0:\\r\\n pos1=7-2*j\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\",\n \"def camino_minimo_bfs(grafo, origen):\\n visitados = set()\\n padres = {}\\n orden = {}\\n cola = collections.deque()\\n\\n visitados.add(origen)\\n padres[origen] = None\\n orden[origen] = 0\\n cola.append(origen)\\n\\n while cola:\\n v = cola.popleft()\\n for w in grafo.adyacentes(v):\\n if w not in visitados:\\n visitados.add(w)\\n padres[w] = v\\n orden[w] = orden[v] + 1\\n cola.append(w)\\n\\n return orden ,padres\",\n \"def fptosi(self, typ):\",\n \"def logits_placeholder(self):\",\n \"def joueCoup(position,coup):\\n nouvelle_pos = clonePosition(position) # on duplique pour ne pas modifier l'original\\n n = nouvelle_pos['taille']\\n trait = nouvelle_pos['trait']\\n # on transforme coup en indice\\n if trait == 'SUD':\\n indice_depart = coup-1\\n else:\\n indice_depart = 2*n-coup\\n # retrait des graines de la case de depart\\n nbGraines = nouvelle_pos['tablier'][indice_depart]\\n nouvelle_pos['tablier'][indice_depart] = 0\\n # on seme les graines dans les cases a partir de celle de depart\\n indice_courant = indice_depart\\n while nbGraines > 0:\\n indice_courant = (indice_courant + 1) % (2*n)\\n if (indice_courant != indice_depart): # si ce n'est pas la case de depart\\n nouvelle_pos['tablier'][indice_courant] += 1 # on seme une graine\\n nbGraines -= 1\\n # la case d'arrivee est dans le camp ennemi ?\\n if (trait == 'NORD'):\\n estChezEnnemi = (indice_courant < n)\\n else:\\n estChezEnnemi = (indice_courant >= n)\\n # realisation des prises eventuelles\\n while estChezEnnemi and (nouvelle_pos['tablier'][indice_courant] in range(2,4)):\\n nouvelle_pos['graines'][trait] += nouvelle_pos['tablier'][indice_courant]\\n nouvelle_pos['tablier'][indice_courant] = 0\\n indice_courant = (indice_courant - 1) % (2*n)\\n if (trait == 'NORD'):\\n estChezEnnemi = (indice_courant < n)\\n else:\\n estChezEnnemi = (indice_courant >= n)\\n # mise a jour du camp au trait\\n if trait == 'SUD':\\n nouvelle_pos['trait'] = 'NORD'\\n else:\\n nouvelle_pos['trait'] = 'SUD'\\n return nouvelle_pos\",\n \"def map():\",\n \"def map(z):\\n pass\",\n \"def soul(f):\\n\\n def is_soul(self, *args, **kwargs):\\n # TODO\\n return f(self, *args, **kwargs)\\n\\n return is_soul\",\n \"def hilfe(self):\\n sZweieck_hilfe(3)\",\n \"def f1_score(self):\",\n \"def mask(self):\",\n \"def exercise_b2_82():\\r\\n pass\",\n \"def exercise_b2_70():\\r\\n pass\",\n \"def sitofp(self, typ):\",\n \"def exercise_b2_106():\\r\\n pass\",\n \"def preprocess(self):\",\n \"def hadamard_function(self, qubits):\\n\\n for qubit in qubits:\\n H | qubit\",\n \"def afficher(dico):\\n return dico\",\n \"def feat():\\n pass\",\n \"def pohyb(seznam_tahu, seznam_ovoce, tah,radky, sloupce):\\n\\n x= seznam_tahu [len(seznam_tahu)-1][0] # [x,y] souradnice noveho tahu\\n y= seznam_tahu [len(seznam_tahu)-1][1]\\n\\n if tah == \\\"s\\\": #sever\\n y -= 1\\n elif tah == \\\"j\\\": #jih\\n y += 1\\n elif tah == \\\"v\\\": #vychod\\n x += 1\\n elif tah == \\\"z\\\": #zapad\\n x -= 1\\n else:\\n print(\\\"Zadal jsi spatne pismeno.\\\" )\\n return()\\n\\n if x<0 or x>sloupce-1 or y<0 or y>radky-1: #tah mimo pole\\n print(\\\"Tah neni mozny, je mimo hraci pole. Opakuj tah.\\\")\\n elif [x,y] in seznam_tahu: #jiz obsazene policko hadem\\n print(\\\"Tah neni mozny, had uz na nem je. Opakuj tah.\\\")\\n elif [x,y] in seznam_ovoce: #policko s ovocem, vola se funkce snez\\n snez (seznam_ovoce, seznam_tahu,[x,y],radky, sloupce)\\n else:\\n seznam_tahu.append([x,y]) #tah na volne policko, prida se tah a odebere posledni bod\\n seznam_tahu.pop(0)\",\n \"def fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw):\\n\\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\\n\\tTocwf=Vk*Ck*Dk/GDen\\n\\treturn Tocwf\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6327021","0.6093654","0.6040308","0.58797973","0.58797973","0.57834095","0.5528101","0.54579514","0.5450377","0.5450377","0.5450377","0.5450377","0.5450377","0.5419264","0.5408628","0.5397332","0.5381069","0.53769577","0.534439","0.528647","0.527526","0.5262158","0.5250062","0.5246996","0.5243076","0.5225895","0.5215842","0.5215842","0.5215842","0.5215842","0.5215842","0.51934975","0.5174052","0.5173889","0.51645714","0.5164068","0.5160801","0.5146826","0.5146562","0.51465464","0.51460433","0.5140813","0.5136475","0.5136475","0.51059645","0.5097713","0.5096854","0.5096617","0.5095647","0.5085681","0.5076065","0.50555557","0.50127447","0.5009198","0.5004312","0.4986503","0.4984816","0.49754053","0.49721494","0.49583462","0.49583462","0.49448764","0.4941742","0.4939169","0.49389306","0.49384448","0.49378583","0.49349943","0.49334994","0.49330017","0.49319628","0.49288228","0.49229756","0.4921013","0.48909608","0.48897296","0.4886178","0.4881965","0.48811066","0.4879888","0.48794442","0.48771924","0.4874842","0.48724204","0.4871041","0.4870623","0.48697636","0.48668915","0.48592964","0.48447996","0.48383543","0.48354727","0.483456","0.48341942","0.4828159","0.4826142","0.48249573","0.48224202","0.48200232","0.4810015","0.4807292"],"string":"[\n \"0.6327021\",\n \"0.6093654\",\n \"0.6040308\",\n \"0.58797973\",\n \"0.58797973\",\n \"0.57834095\",\n \"0.5528101\",\n \"0.54579514\",\n \"0.5450377\",\n \"0.5450377\",\n \"0.5450377\",\n \"0.5450377\",\n \"0.5450377\",\n \"0.5419264\",\n \"0.5408628\",\n \"0.5397332\",\n \"0.5381069\",\n \"0.53769577\",\n \"0.534439\",\n \"0.528647\",\n \"0.527526\",\n \"0.5262158\",\n \"0.5250062\",\n \"0.5246996\",\n \"0.5243076\",\n \"0.5225895\",\n \"0.5215842\",\n \"0.5215842\",\n \"0.5215842\",\n \"0.5215842\",\n \"0.5215842\",\n \"0.51934975\",\n \"0.5174052\",\n \"0.5173889\",\n \"0.51645714\",\n \"0.5164068\",\n \"0.5160801\",\n \"0.5146826\",\n \"0.5146562\",\n \"0.51465464\",\n \"0.51460433\",\n \"0.5140813\",\n \"0.5136475\",\n \"0.5136475\",\n \"0.51059645\",\n \"0.5097713\",\n \"0.5096854\",\n \"0.5096617\",\n \"0.5095647\",\n \"0.5085681\",\n \"0.5076065\",\n \"0.50555557\",\n \"0.50127447\",\n \"0.5009198\",\n \"0.5004312\",\n \"0.4986503\",\n \"0.4984816\",\n \"0.49754053\",\n \"0.49721494\",\n \"0.49583462\",\n \"0.49583462\",\n \"0.49448764\",\n \"0.4941742\",\n \"0.4939169\",\n \"0.49389306\",\n \"0.49384448\",\n \"0.49378583\",\n \"0.49349943\",\n \"0.49334994\",\n \"0.49330017\",\n \"0.49319628\",\n \"0.49288228\",\n \"0.49229756\",\n \"0.4921013\",\n \"0.48909608\",\n \"0.48897296\",\n \"0.4886178\",\n \"0.4881965\",\n \"0.48811066\",\n \"0.4879888\",\n \"0.48794442\",\n \"0.48771924\",\n \"0.4874842\",\n \"0.48724204\",\n \"0.4871041\",\n \"0.4870623\",\n \"0.48697636\",\n \"0.48668915\",\n \"0.48592964\",\n \"0.48447996\",\n \"0.48383543\",\n \"0.48354727\",\n \"0.483456\",\n \"0.48341942\",\n \"0.4828159\",\n \"0.4826142\",\n \"0.48249573\",\n \"0.48224202\",\n \"0.48200232\",\n \"0.4810015\",\n \"0.4807292\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14894,"cells":{"query":{"kind":"string","value":"Compute average return and of steps."},"document":{"kind":"string","value":"def compute_avg_return_and_steps(environment, policy, num_episodes=10):\n total_return = 0.0\n total_steps = 0.0\n for _ in range(num_episodes):\n\n time_step = environment.reset()\n episode_return = 0.0\n episode_steps = 0.0\n\n while not time_step.is_last():\n action_step = policy.action(time_step)\n time_step = environment.step(action_step.action)\n episode_return += time_step.reward\n episode_steps += 1\n total_return += episode_return\n total_steps += episode_steps\n\n average_return = total_return / num_episodes\n average_episode_steps = total_steps / num_episodes\n return average_return.numpy()[0], average_episode_steps"},"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_mean(self, sums, step):\n\n return sums/step","def calculate(self):\n avg = self.sum / self.n if self.n != 0 else 0\n self.running_avg.append(avg)\n return avg","def average(self):\n return (self.current + self.last) / 2.0","def average(self, start, end):\n return self.integrate(start, end) / (end - start)","def average(self, returns):\r\n return returns.mean() * self.day","def average(self):\n return self.summation() / self.count()","def average(self):\n total = 0\n for t in self.memory:\n total += t.reward\n return total/self.__len__()","def calculateAverage(self, data):\n\n nValidTrials = data['nValid'][-1]\n nRewardTrials = data['nRewarded'][-1]\n return float(nRewardTrials)/nValidTrials","def total_steps(self) -> global___Expression:","def avg_return(pct_returns, daily_investment=100, skip_n_steps=0):\n return np.sum(np.multiply(daily_investment, np.average(pct_returns.T, axis=1)[skip_n_steps:]))","def averageTime(self):\n \n pass","def compute_avg_reward(env, policy, num_episodes):\n total_return = 0.0\n for _ in range(num_episodes):\n state = env.reset()\n done = False\n episode_return = 0.0\n while not done:\n action = policy(state)\n next_state, reward, done, _ = env.step(action)\n if done:\n reward = -1.0\n episode_return += reward\n state = next_state\n total_return += episode_return\n avg_return = total_return / num_episodes\n return avg_return","def avg(a,b):\r\n return (a+b)/2","def avgtr(self):\n return np.diff(self.trtimes).mean()","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def average(self):\n\n x = list(zip(*self.memory))\n states = list(x[0])\n actions = list(x[1])\n \n downsampled_states = resample(states , self.output_size-1)\n downsampled_actions = resample(actions, self.output_size-1)\n\n return downsampled_states, downsampled_actions","def get_average(self):\n self.avg = math.floor((self.maths + self.phy + self.che) / 3, )\n self.assign_grade()\n return self.avg\n # End of method get_average","def calc_mean(a, b, c, d, e):\n return (a + b + c + d + e) / 5","def average(arg1, *args): \n return (arg1 + sum(args)) / (1 + len(args))","def geo_average(self, returns):\r\n return (1 + returns).prod() ** (self.day / len(returns)) - 1","def main():\n print(average([2, 4, 6, 8, 20, 50, 70]))","def averageDistance(nbSteps, nbWalks, func):\n totalDistance = 0\n startPoint = (0, 0)\n for _ in range(nbWalks):\n arrival = None\n while arrival is None:\n arrival = func(startPoint, nbSteps)\n totalDistance += distance(startPoint, arrival)\n return pow(totalDistance/nbWalks, 2)","def print_avg():","def getAverage(die, numRolls, numTrials):","def average(x, y):\n #helper function for get_accuracy\n average = (x+y)/2 \n return average","def get_average_torsion (phis) :\n shift = phis[0]\n phis_shifted = get_diffvec(phis,shift)\n avg_shifted = phis_shifted.sum()/len(phis)\n average = avg_shifted + shift\n return average","def get_average_torsion (phis) :\n shift = phis[0]\n phis_shifted = get_diffvec(phis,shift)\n avg_shifted = phis_shifted.sum()/len(phis)\n average = avg_shifted + shift\n return average","def get_runs_to_average(self):\n\n if Test.performance_params: return int(Test.performance_params[1])\n elif self._check_performance: return self._runs_to_average\n else: return None","def get_final_return(self):\n values = self.stats['return_stats']['episode_totals']\n _, y, (_, _) = self._moving_average(values, window=_ROLLING_WINDOW,\n p=_CONFIDENCE_LEVEL)\n return y[-1]","def _run_eval_phase(self, statistics, agent_type='active'):\n # Perform the evaluation phase -- no learning.\n self._agent.eval_mode = True\n _, sum_returns, num_episodes = self._run_one_phase(\n self._evaluation_steps, statistics, 'eval', agent_type)\n average_return = sum_returns / num_episodes if num_episodes > 0 else 0.0\n logging.info('Average undiscounted return per eval episode (%s): %.2f',\n agent_type, average_return)\n statistics.append({f'{agent_type}_eval_average_return': average_return})\n return num_episodes, average_return","def calc_av_daily_return(self):\n av_return = 0.0\n total_ret = sum(self._returns)\n num_averages = len(self._returns)\n \n if num_averages > 0:\n av_return = total_ret/float(num_averages)\n \n self._av_daily_return = av_return\n return av_return","def expected_return(self, n_step):\r\n value = 0\r\n n_experiences = 50\r\n for i in range(n_experiences):\r\n trajectory = self.domain_exploration(n_step)\r\n value += self.compute_j(trajectory)\r\n return value/n_experiences","def data_flow_steps_avg(self) -> Optional[float]:\n if self.has_data_flow:\n return float(self.graph_tuple_stats.data_flow_steps_avg)","def eta_scan_averages(self):\n return self._eta_scan_averages","def avg_len(steps):\n lens = []\n for i in steps:\n lens.append(len(i))\n avg = sum(lens) / float(len(lens))\n return avg","def calculateAverage(self): \n if not self.lastTransferAverage: \n size=[0,0,0,0]\n for i in range(0,4):\n if self.lastTransferredChannel & (1 << i):\n size[i]=self.lastNbrSamplesPerSeg\n self.lastAverageArray = [zeros(size[0]),zeros(size[1]),zeros(size[2]),zeros(size[3])]\n nbrSamp=self.lastNbrSamplesPerSeg\n for i in range(0,4):\n if self.lastTransferredChannel & (1 << i):\n nbrSeg=self.lastNbrSegmentsArray[i]\n for j in range (0,nbrSamp):\n for k in range(0,nbrSeg): \n self.lastAverageArray[i][j]+=self.lastWaveformArray[i][k*nbrSamp+j]\n self.lastAverageArray[i][j]/=nbrSeg\n self.lastAverageCalculated=True\n else: print \"NOn averaged data are not available\"","def gmrae(self, benchmark: np.ndarray = None) -> float:\n return _geometric_mean(np.abs(self._relative_error(benchmark)))","def average_evaluations(self, n):\n\n assert(self.history_count > 0), \"not enough evaluations in average_evaluations!\"\n\n n = max(1, min(1000, n))\n n = min(n, self.history_count)\n # print(f'n = {n}')\n # print(f'hist_cnt = {self.history_count}')\n\n sum_eval = 0.0\n sum_theta = utils.linear_combinaison(0.0, self.theta0)\n for i in range(n):\n\n j = ((self.history_count - 1) % 1000) - i\n if j < 0:\n j += 1000\n if j >= 1000:\n j -= 1000\n\n # print(f'i={i}, j={j}, hist_cnt: {self.history_count}, hist_eval[{j}] = {self.history_eval[j]}')\n\n sum_eval += self.history_eval[j]\n sum_theta = utils.sum(sum_theta, self.history_theta[j])\n\n # return the average\n alpha = 1.0 / (1.0 * n)\n return (alpha * sum_eval, utils.linear_combinaison(alpha, sum_theta))","def update_average(self,result):\n a = 1/self.iters\n b = 1 - a\n self.average = a * result + b * self.average\n self.iters += 1","def average(num1, num2):\n\n return (num1 + num2) / 2","def arithmetic_ret(self) -> float:\n return float(np.log(self.tsdf).diff().mean() * self.periods_in_a_year)","def average(entry):\n return entry['total time (s)'] / float(entry['correct answers'] + entry['wrong answers'])","def calculate_average_run_accuracy(self):\n overall_true_rate, true_positive_rate, true_negative_rate, false_positive_rate, false_negative_rate, true_positive_rate_cutoff, true_negative_rate_cutoff, \\\n false_positive_rate_cutoff, false_negative_rate_cutoff, unclassified_cutoff, matthews_correlation_coefficient, brier_score, auc_score, fit_time, hmeasure = [0] * 15\n balanced_accuracy_arr = []\n auc_arr = []\n hmeasure_arr = []\n brier_score_arr = []\n fit_time_arr = []\n mcc_arr = []\n true_positive_arr = []\n true_negative_arr = []\n false_positive_arr = []\n false_negative_arr = []\n\n count = 0\n for result_dictionary in self.errors:\n for z in range(len(result_dictionary[\"balanced_accuracy_arr\"])):\n overall_true_rate += result_dictionary[\"balanced_accuracy_arr\"][z]\n true_positive_rate += result_dictionary[\"true_positive_rate_arr\"][z]\n true_negative_rate += result_dictionary[\"true_negative_rate_arr\"][z]\n false_positive_rate += result_dictionary[\"false_positive_rate_arr\"][z]\n false_negative_rate += result_dictionary[\"false_negative_rate_arr\"][z]\n matthews_correlation_coefficient += result_dictionary[\"mcc_arr\"][z]\n auc_score += result_dictionary[\"auc_arr\"][z]\n brier_score += result_dictionary[\"brier_score_arr\"][z]\n fit_time += result_dictionary[\"fit_time_arr\"][z]\n hmeasure += result_dictionary[\"hmeasure_arr\"][z]\n count += 1\n\n true_positive_rate_cutoff += result_dictionary[\"avg_true_positive_rate_with_prob_cutoff\"]\n true_negative_rate_cutoff += result_dictionary[\"avg_true_negative_rate_with_prob_cutoff\"]\n false_positive_rate_cutoff += result_dictionary[\"avg_false_positive_rate_with_prob_cutoff\"]\n false_negative_rate_cutoff += result_dictionary[\"avg_false_negative_rate_with_prob_cutoff\"]\n unclassified_cutoff += result_dictionary[\"avg_false_negative_rate_with_prob_cutoff\"]\n balanced_accuracy_arr += result_dictionary[\"balanced_accuracy_arr\"]\n hmeasure_arr += result_dictionary[\"hmeasure_arr\"]\n auc_arr += result_dictionary[\"auc_arr\"]\n brier_score_arr += result_dictionary[\"brier_score_arr\"]\n fit_time_arr += result_dictionary[\"fit_time_arr\"]\n mcc_arr += result_dictionary[\"mcc_arr\"]\n true_positive_arr += result_dictionary[\"true_positive_rate_arr\"]\n true_negative_arr += result_dictionary[\"true_negative_rate_arr\"]\n false_positive_arr += result_dictionary[\"false_positive_rate_arr\"]\n false_negative_arr += result_dictionary[\"false_negative_rate_arr\"]\n\n avg_run_results = [None] * 31\n avg_run_results[0] = matthews_correlation_coefficient / float(count)\n avg_run_results[1] = brier_score / float(count)\n avg_run_results[2] = overall_true_rate / float(count)\n avg_run_results[3] = true_positive_rate / float(count)\n avg_run_results[4] = true_negative_rate / float(count)\n avg_run_results[5] = false_positive_rate / float(count)\n avg_run_results[6] = false_negative_rate / float(count)\n avg_run_results[7] = true_positive_rate_cutoff / float(len(self.errors))\n avg_run_results[8] = true_negative_rate_cutoff / float(len(self.errors))\n avg_run_results[9] = false_positive_rate_cutoff / float(len(self.errors))\n avg_run_results[10] = false_negative_rate_cutoff / float(len(self.errors))\n avg_run_results[11] = unclassified_cutoff / float(len(self.errors))\n avg_run_results[12] = fit_time / float(count)\n avg_run_results[14] = balanced_accuracy_arr\n avg_run_results[15] = auc_score / float(count)\n avg_run_results[16] = auc_arr\n avg_run_results[17] = brier_score_arr\n avg_run_results[18] = fit_time_arr\n avg_run_results[19] = mcc_arr\n avg_run_results[13] = self.calculate_std_deviation(balanced_accuracy_arr)\n avg_run_results[20] = self.calculate_std_deviation(mcc_arr)\n avg_run_results[21] = self.calculate_std_deviation(brier_score_arr)\n avg_run_results[22] = self.calculate_std_deviation(auc_arr)\n avg_run_results[23] = self.calculate_std_deviation(fit_time_arr)\n avg_run_results[24] = self.calculate_std_deviation(true_positive_arr)\n avg_run_results[25] = self.calculate_std_deviation(true_negative_arr)\n avg_run_results[26] = self.calculate_std_deviation(false_positive_arr)\n avg_run_results[27] = self.calculate_std_deviation(false_negative_arr)\n avg_run_results[28] = hmeasure / float(count)\n avg_run_results[29] = self.calculate_std_deviation(hmeasure_arr)\n avg_run_results[30] = hmeasure_arr\n\n return avg_run_results","def _evaluate(self, estimator, generator):\n return np.mean([np.mean(np.power(estimator.estimate(A, b) - x, 2))\n for A, x, b in[generator.generate()\n for _ in range(self.repetitions)]])","def cal_average_kill_turns(deck):\n #Results array\n turn_results = np.zeros(NUM_SIMS)\n \n #Simulation loop\n for i in range(NUM_SIMS): \n if VERBOSE:\n print('Running simulation ' + str(i + 1)) \n turn_results[i] = cal_kill_turn(copy.deepcopy(deck))\n #End of Simulations\n \n #DETERMINE ATK\n average_kill_turn = np.average(turn_results)\n min_kill_turn = np.min(turn_results)\n max_kill_turn = np.max(turn_results)\n \n return average_kill_turn, min_kill_turn, max_kill_turn","def average_reward(self):\n T = len(self)\n return np.sum(self.rewards / T)","def getAverage(self):\n return sum(self.scores) / len(self.scores)","def average(grade1, grade2, grade3):\n return (grade1 + grade2 + grade3) / 3","def time_average(self, time_since_out, time_step):\n\n for variable in self._energy_state:\n bar_variable = \"{}_bar\".format(variable)\n bar_value = getattr(self, bar_variable)\n ta = time_average(bar_value, time_since_out,\n getattr(self, variable), time_step)\n setattr(self, bar_variable, ta)\n\n self.E_s_sum += self.E_s\n self.melt_sum += self.melt\n self.swi_sum += self.swi","def moving_average(position, step_size, avg_quantity):\n print(\"1\")\n avg_disp = int(math.floor(avg_quantity / 2))\n start_frame = step_size + avg_disp + 1\n end_frame = len(position) - avg_disp\n moving_avg = []\n for i in range(start_frame, end_frame + 1):\n position_avg = 0\n for j in range(i - 1 - avg_disp, i + avg_disp):\n position_avg += position[j]\n position_1 = position_avg / (avg_disp * 2 + 1)\n \n moving_avg.append(position_1)\n print(\"2\")\n return start_frame, end_frame, moving_avg","def step(self, data: torch.Tensor) -> Tuple:\r\n image, _ = data\r\n image = image.to(self.device)\r\n batch_size = image.shape[0]\r\n label = torch.full(\r\n (batch_size,), self.label, dtype=torch.float, device=self.device\r\n )\r\n self.zero_grad()\r\n # Forward pass\r\n output = self(image).view(-1)\r\n # Calculate loss on a batch\r\n err = self.criterion(output, label)\r\n err.backward()\r\n avg_out = output.mean().item()\r\n self.optimizer.step()\r\n return avg_out","def _determine_step(self):\r\n\r\n step_sizes = np.empty(len(self.h))\r\n\r\n for i in range(step_sizes.shape[0]):\r\n step_sizes[i] = np.mean(np.diff(self.h[i], n=1))\r\n\r\n return np.mean(step_sizes)","def average(values):\n return sum(values) / len(values)","def average(values):\n return sum(values) / len(values)","def trial_atr(trial, omit_missing_frames=True):\n frames = trial.HMM_MLE\n if omit_missing_frames:\n frames = frames[frames >= 0]\n\n runs = calc_run_lengths(trial.HMM_MLE)\n return_times = []\n current_return_time = 0\n for run in runs:\n if run.object == 0:\n return_times.append(current_return_time/60)\n current_return_time = 0\n else:\n current_return_time += run.length\n return np.mean(return_times)","def x_run_average_pipeline(num: int, language: str):\n precision, recall, f1 = [], [], []\n for i in range(num):\n CRF = BaselineCRF(language)\n predicted, labels = CRF.pipeline()\n p, r, f = eval_morph_segments(predicted, labels)\n precision.append(p)\n recall.append(r)\n f1.append(f)\n\n recall = sum(recall) / len(recall)\n precision = sum(precision) / len(precision)\n f1 = sum(f1) / len(f1)\n return recall, precision, f1","def average(values):\n\treturn sum(values)/len(values)","def average(data, event):\n if len(data) == 0:\n return 0\n\n score = 0\n # scores = []\n count = 0\n for i in data:\n count += 1\n if event == 'Swim' or event == 'Run':\n num = time_seconds(i[event])\n #print(\"first if\")\n #Sprint(num)\n else:\n num = int(i[event])\n #print(\"second if\")\n #print(num)\n #scores[count] =\n #print(\"end of loop count\" + str(count))\n score += num\n #print (\"score\" + str(score))\n\n # total = 0\n # for x in range(0,len(scores)):\n # total += scores[x]\n score = float(score)\n\n return score / count","def result (result = None):\n if result is not None:\n results.append (float (result))\n\n if len (results) < self.min_count:\n return None, None\n\n result_mean = functools.reduce (operator.add, results, 0) / len (results)\n result_error = (functools.reduce (operator.add,\n ((result - result_mean)**2 for result in results), 0) / (len (results) - 1))\n return result_mean, result_error","def average(self):\n s = self.sum()\n flat_shape = self.flatten_shape(self.shape)\n num_of_elements = fct.reduce(opr.mul, flat_shape, 1)\n average = s / num_of_elements\n return average","def avg(realizations, results):\n avg_nmi, avg_snmi, avg_ari, avg_vi, avg_purity, avg_fmeasure = 0,0,0,0,0,0\n for nmi, snmi, ari, vi, purity, f_measure in results:\n avg_nmi += nmi\n avg_snmi += snmi\n avg_purity += purity\n avg_fmeasure += f_measure\n avg_vi += vi\n avg_ari += ari\n\n return round(avg_nmi/realizations, 3), round(avg_snmi/realizations, 3), round(avg_ari/realizations, 3), round(avg_vi/realizations, 3), round(avg_purity/realizations, 3), round(avg_fmeasure/realizations, 3)","def average(ls):\n\n if len(ls) == 0:\n return 0.0\n\n sm = sum(ls)\n return sm / len(ls)","def get_average_repro(self):\n return np.mean([agent.get_fledge_probability() for agent in self.agents])","def calc_average(numbers):\n return sum(numbers) // len(numbers) # integer division //","def experiment(agent, steps, runs, initialize=None):\n result = 0\n for r in range(runs):\n result += simulate(agent, steps, initialize)\n return result / runs","def avg_performance(env, policy):\n\n sum_reward = 0.\n episode = 100\n max_iteration = 6000\n for i in range(episode):\n done = False\n ob = env.reset()\n\n for j in range(max_iteration):\n a = policy[ob]\n ob, reward, done, _ = env.step(a)\n sum_reward += reward\n if done:\n break\n\n return sum_reward / i","def calcAverage(dat):\n return sum(dat)/len(dat)","def em_mean(self) -> float:\n if self.__total_pulls == 0:\n raise Exception('Number of pulls is 0. No empirical mean.')\n return self.__total_rewards / self.__total_pulls","def get_avg_points(self):\n pass","def running_mean(sequence: list):\n if not sequence:\n return []\n\n mean = []\n \"\"\"\n [1] = 1 / 1\n [1,2] = 3 / 2 \n [1,2,3] = 6 / 3\n \"\"\"\n for idx, num in enumerate(sequence):\n\n sum_total = sum(sequence[:(idx + 1)])\n result = sum_total / (idx + 1)\n\n mean.append(round(result, 2))\n\n return mean","def calculate(self) -> float:","def dishlist_avg_cal(n:list)->float:\r\n all_cal = dishlist_cal(n)\r\n return sum(all_cal)/len(all_cal)","def avg_func(self, averaged_param: Tensor, source_param: Tensor,\n steps: int) -> None:\n averaged_param.mul_(1 - self.momentum).add_(\n source_param, alpha=self.momentum)","def make_averaged(fn, num_samples=1000):\n # BEGIN PROBLEM 8\n \"*** YOUR CODE HERE ***\"\n def return_average(*args):\n k, total = 0, 0\n while k < num_samples:\n total += fn(*args)\n k += 1\n return total / num_samples\n return return_average\n # END PROBLEM 8","def compute_average(self, error=None):\n\n nbjobs = len(self)\n if not nbjobs:\n return\n max_xsec = max(one.xsec for one in self)\n min_xsec = min(one.xsec for one in self)\n self.axsec = sum([one.axsec for one in self]) / nbjobs\n self.xsec = sum([one.xsec for one in self]) /nbjobs\n self.xerrc = sum([one.xerrc for one in self]) /nbjobs\n self.xerru = math.sqrt(sum([one.xerru**2 for one in self])) /nbjobs\n if error:\n self.xerrc = error\n self.xerru = error\n\n self.nevents = sum([one.nevents for one in self])\n self.nw = 0#sum([one.nw for one in self])\n self.maxit = 0#len(self.yerr_iter) # \n self.nunwgt = sum([one.nunwgt for one in self]) \n self.wgt = 0\n self.luminosity = sum([one.luminosity for one in self])\n self.ysec_iter = []\n self.yerr_iter = []\n self.th_maxwgt = 0.0\n self.th_nunwgt = 0 \n for result in self:\n self.ysec_iter+=result.ysec_iter\n self.yerr_iter+=result.yerr_iter\n self.yasec_iter += result.yasec_iter\n self.eff_iter += result.eff_iter\n self.maxwgt_iter += result.maxwgt_iter\n\n #check full consistency\n onefail = False\n for one in list(self):\n if one.xsec < (self.xsec - 25* one.xerru):\n if not onefail:\n logger.debug('multi run are inconsistent: %s < %s - 25* %s: assign error %s', one.xsec, self.xsec, one.xerru, error if error else max_xsec-min_xsec)\n onefail = True\n self.remove(one)\n if onefail:\n if error:\n return self.compute_average(error)\n else:\n return self.compute_average((max_xsec-min_xsec)/2.)","def moving_average(a, n=3) :\n ret = np.cumsum(a, dtype=float)\n ret[n:] = ret[n:] - ret[:-n]\n return ret[n - 1:] / n","def find_arithmetic_mean( *args):\n sum = 0\n for value in args:\n sum += value\n return sum/len(args)","def average(self, n=0):\n assert n >= 0\n for key in self.value_history:\n values = np.array(self.value_history[key][-n:])\n nums = np.array(self.n_history[key][-n:])\n avg = np.sum(values * nums) / np.sum(nums)\n self.output[key] = avg","def update(self,x): #update the estimate of rewards and number of esteps run\n\t\tself.N += 1\n\t\tself.estimate_mean = (1.0-1.0/self.N)*self.estimate_mean + (1.0/self.N)*x #recurence relation for averages","def reduce_by_averaging(trials, total, amount):\n new_averages = []\n\n for i in range(0, total):\n if i % amount == 0:\n new_averages.append(reduce(lambda x, y: x + y, trials[i:i+amount]) / \\\n amount)\n\n return new_averages","def moving_average(self, a, n=3):\n ret = np.nancumsum(a, dtype=float)\n ret[n:] = ret[n:] - ret[:-n]\n return ret[n - 1:] / n","def _ave(self):\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def get_avg(self) -> float:\n if self._cur_elem_count < 1:\n return 0\n self._mtx.acquire()\n avg = self._sum / float(self._cur_elem_count)\n self._mtx.release()\n return avg","def _ave(self):\n\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def get_average(self) -> float:\n return sum(self._scores) / len(self._scores)","def avg(x, y):\n return (x + y)/2","def average_grad(self):\n\n # Compute the respective gradients\n grad_line_1 = self.gradient(0,1)\n grad_line_2 = self.gradient(2,3)\n\n a1 = np.abs(np.arctan(grad_line_1))\n a2 = np.abs(np.arctan(grad_line_2))\n\n ave_grad = np.tan((a1+a2)/2)\n\n #ave_grad = np.average([grad_line_1,grad_line_2]) # Compute the average gradient\n\n return ave_grad","def average(cls, points):\n return Point.sum(points) / len(points)","def function2(a, b):\r\n average = (a + b) / 2\r\n return average","def average(data):\n return np.average(data)","def stochastic_average(h, a, alpha, numsteps, numiter):\n #Same times for all trajectories\n times = zeros(numsteps+1)\n trajectories = zeros((numiter, numsteps+1, 2))\n\n #Initial phase\n phase = random.uniform(0, 1)\n for i in range(numiter):\n times, trajectories[i] = EulerInteg(h, a, alpha, numsteps, phase)\n\n stochastic_av = zeros((numsteps+1, 2))\n for j in range(numsteps+1):\n average_pos = array([0., 0.])\n for k in range(numiter):\n average_pos = average_pos + trajectories[k][j]\n stochastic_av[j] = average_pos/numiter\n\n return times, stochastic_av","def calculate(self):\n self.results['max'] = numpy.max(self.data)\n self.results['min'] = numpy.min(self.data)\n if self.type == 0:\n self.group_discrete_data()\n if self.type == 1:\n self.group_continuous_data()\n\n self.results['arithAvg'] = self.average([self.data[i] * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences)\n self.results['quadAvg'] = math.sqrt(\n self.average([(self.data[i] * self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences))\n if self.results['min'] > 0:\n self.results['geoAvg'] = math.exp(\n self.average([numpy.log(self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences))\n self.results['harmAvg'] = 1 / self.average(\n [(self.occurrences[i] / self.data[i]) for i in range(len(self.data))],\n self.totalOccurrences)\n else:\n self.results['geoAvg'] = self.results['harmAvg'] = \"N/A\"\n self.results['momentsR'] = self.moments(self.data, self.occurrences, 4)\n self.results['centralMomentsR'] = self.moments([(i - self.results['arithAvg']) for i in self.data],\n self.occurrences, 4)\n self.results['std'] = self.average(\n [self.occurrences[i] * abs(self.data[i] - self.results['arithAvg']) for i in range(len(self.data))],\n self.totalOccurrences)","def get_average(data):\n average = sum(data) / len(data)\n\n return average","def average(self, times=2):\n for i in range(times):\n self.statistics()\n global t, avlist\n length = len(t)\n avlist.append(t)\n t = []\n\n total_list = []\n\n for l in range(length):\n total_list.append([])\n\n for j in range(times):\n \"\"\"per time\"\"\"\n for i in range(length):\n total_list[i].append(avlist[j][i])\n\n \"\"\"calculate\"\"\"\n ylist = []\n avlist = []\n for a in total_list:\n avg = 0\n for b in a:\n avg += b\n ylist.append(avg/times)\n self.listy = ylist\n\n for e in range(self.el[self.re[0]], self.re[1], self.re[2]):\n self.listx.append(e)","def average_energy(power,events,borders,eventName):\n event_consider = events[events['eventName']==eventName].reset_index(drop=True)\n average = 0\n i = 0\n count = 0\n minValue = 10000\n maxValue = 0\n minAverage = 10000\n maxAverage = 0 \n while(i<len(event_consider)):\n date = time.mktime(datetime.strptime(event_consider['time'][i], \"%Y-%m-%d %H:%M:%S\").timetuple())\n start = str(datetime.fromtimestamp(date+borders[0]))\n end = str(datetime.fromtimestamp(date+borders[1]))\n values = power[(power['time']>=start)&(power['time']<=end)]['value']\n sum_values = sum(values)\n tot_values = len(values)\n if tot_values>0:\n if values.max() > maxValue:\n maxValue = values.max()\n if values.min() < minValue:\n minValue = values.min()\n if sum_values/tot_values > maxAverage:\n maxAverage = sum_values/tot_values\n if sum_values/tot_values < minAverage:\n minAverage = sum_values/tot_values\n average = average + sum_values/tot_values\n count += 1\n i += 1\n if count>0:\n average = average / count\n print(\"number of\", eventName ,\"in groudtruth and power=\",count)\n print(\"minValue=\",minValue,\"maxValue=\",maxValue)\n print(\"minAverage=\",minAverage,\"maxAverage=\",maxAverage)\n print(\"Final Av=\",average)\n return average\n else:\n print(\"Not values found in the range\")","def avg_hops(self):\n return self._avg_hops","def mrae(self, benchmark: np.ndarray = None):\n return float(np.mean(np.abs(self._relative_error(benchmark))))","def avg_func(self, averaged_param: Tensor, source_param: Tensor,\n steps: int) -> None:\n momentum = 1. - self.rampup(self.steps, self.ema_kimg, self.ema_rampup,\n self.batch_size, self.eps)\n if not (0.0 < momentum < 1.0):\n warnings.warn('RampUp momentum must be in range (0.0, 1.0)'\n f'but got {momentum}')\n averaged_param.mul_(1 - momentum).add_(source_param, alpha=momentum)"],"string":"[\n \"def _get_mean(self, sums, step):\\n\\n return sums/step\",\n \"def calculate(self):\\n avg = self.sum / self.n if self.n != 0 else 0\\n self.running_avg.append(avg)\\n return avg\",\n \"def average(self):\\n return (self.current + self.last) / 2.0\",\n \"def average(self, start, end):\\n return self.integrate(start, end) / (end - start)\",\n \"def average(self, returns):\\r\\n return returns.mean() * self.day\",\n \"def average(self):\\n return self.summation() / self.count()\",\n \"def average(self):\\n total = 0\\n for t in self.memory:\\n total += t.reward\\n return total/self.__len__()\",\n \"def calculateAverage(self, data):\\n\\n nValidTrials = data['nValid'][-1]\\n nRewardTrials = data['nRewarded'][-1]\\n return float(nRewardTrials)/nValidTrials\",\n \"def total_steps(self) -> global___Expression:\",\n \"def avg_return(pct_returns, daily_investment=100, skip_n_steps=0):\\n return np.sum(np.multiply(daily_investment, np.average(pct_returns.T, axis=1)[skip_n_steps:]))\",\n \"def averageTime(self):\\n \\n pass\",\n \"def compute_avg_reward(env, policy, num_episodes):\\n total_return = 0.0\\n for _ in range(num_episodes):\\n state = env.reset()\\n done = False\\n episode_return = 0.0\\n while not done:\\n action = policy(state)\\n next_state, reward, done, _ = env.step(action)\\n if done:\\n reward = -1.0\\n episode_return += reward\\n state = next_state\\n total_return += episode_return\\n avg_return = total_return / num_episodes\\n return avg_return\",\n \"def avg(a,b):\\r\\n return (a+b)/2\",\n \"def avgtr(self):\\n return np.diff(self.trtimes).mean()\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def average(self):\\n\\n x = list(zip(*self.memory))\\n states = list(x[0])\\n actions = list(x[1])\\n \\n downsampled_states = resample(states , self.output_size-1)\\n downsampled_actions = resample(actions, self.output_size-1)\\n\\n return downsampled_states, downsampled_actions\",\n \"def get_average(self):\\n self.avg = math.floor((self.maths + self.phy + self.che) / 3, )\\n self.assign_grade()\\n return self.avg\\n # End of method get_average\",\n \"def calc_mean(a, b, c, d, e):\\n return (a + b + c + d + e) / 5\",\n \"def average(arg1, *args): \\n return (arg1 + sum(args)) / (1 + len(args))\",\n \"def geo_average(self, returns):\\r\\n return (1 + returns).prod() ** (self.day / len(returns)) - 1\",\n \"def main():\\n print(average([2, 4, 6, 8, 20, 50, 70]))\",\n \"def averageDistance(nbSteps, nbWalks, func):\\n totalDistance = 0\\n startPoint = (0, 0)\\n for _ in range(nbWalks):\\n arrival = None\\n while arrival is None:\\n arrival = func(startPoint, nbSteps)\\n totalDistance += distance(startPoint, arrival)\\n return pow(totalDistance/nbWalks, 2)\",\n \"def print_avg():\",\n \"def getAverage(die, numRolls, numTrials):\",\n \"def average(x, y):\\n #helper function for get_accuracy\\n average = (x+y)/2 \\n return average\",\n \"def get_average_torsion (phis) :\\n shift = phis[0]\\n phis_shifted = get_diffvec(phis,shift)\\n avg_shifted = phis_shifted.sum()/len(phis)\\n average = avg_shifted + shift\\n return average\",\n \"def get_average_torsion (phis) :\\n shift = phis[0]\\n phis_shifted = get_diffvec(phis,shift)\\n avg_shifted = phis_shifted.sum()/len(phis)\\n average = avg_shifted + shift\\n return average\",\n \"def get_runs_to_average(self):\\n\\n if Test.performance_params: return int(Test.performance_params[1])\\n elif self._check_performance: return self._runs_to_average\\n else: return None\",\n \"def get_final_return(self):\\n values = self.stats['return_stats']['episode_totals']\\n _, y, (_, _) = self._moving_average(values, window=_ROLLING_WINDOW,\\n p=_CONFIDENCE_LEVEL)\\n return y[-1]\",\n \"def _run_eval_phase(self, statistics, agent_type='active'):\\n # Perform the evaluation phase -- no learning.\\n self._agent.eval_mode = True\\n _, sum_returns, num_episodes = self._run_one_phase(\\n self._evaluation_steps, statistics, 'eval', agent_type)\\n average_return = sum_returns / num_episodes if num_episodes > 0 else 0.0\\n logging.info('Average undiscounted return per eval episode (%s): %.2f',\\n agent_type, average_return)\\n statistics.append({f'{agent_type}_eval_average_return': average_return})\\n return num_episodes, average_return\",\n \"def calc_av_daily_return(self):\\n av_return = 0.0\\n total_ret = sum(self._returns)\\n num_averages = len(self._returns)\\n \\n if num_averages > 0:\\n av_return = total_ret/float(num_averages)\\n \\n self._av_daily_return = av_return\\n return av_return\",\n \"def expected_return(self, n_step):\\r\\n value = 0\\r\\n n_experiences = 50\\r\\n for i in range(n_experiences):\\r\\n trajectory = self.domain_exploration(n_step)\\r\\n value += self.compute_j(trajectory)\\r\\n return value/n_experiences\",\n \"def data_flow_steps_avg(self) -> Optional[float]:\\n if self.has_data_flow:\\n return float(self.graph_tuple_stats.data_flow_steps_avg)\",\n \"def eta_scan_averages(self):\\n return self._eta_scan_averages\",\n \"def avg_len(steps):\\n lens = []\\n for i in steps:\\n lens.append(len(i))\\n avg = sum(lens) / float(len(lens))\\n return avg\",\n \"def calculateAverage(self): \\n if not self.lastTransferAverage: \\n size=[0,0,0,0]\\n for i in range(0,4):\\n if self.lastTransferredChannel & (1 << i):\\n size[i]=self.lastNbrSamplesPerSeg\\n self.lastAverageArray = [zeros(size[0]),zeros(size[1]),zeros(size[2]),zeros(size[3])]\\n nbrSamp=self.lastNbrSamplesPerSeg\\n for i in range(0,4):\\n if self.lastTransferredChannel & (1 << i):\\n nbrSeg=self.lastNbrSegmentsArray[i]\\n for j in range (0,nbrSamp):\\n for k in range(0,nbrSeg): \\n self.lastAverageArray[i][j]+=self.lastWaveformArray[i][k*nbrSamp+j]\\n self.lastAverageArray[i][j]/=nbrSeg\\n self.lastAverageCalculated=True\\n else: print \\\"NOn averaged data are not available\\\"\",\n \"def gmrae(self, benchmark: np.ndarray = None) -> float:\\n return _geometric_mean(np.abs(self._relative_error(benchmark)))\",\n \"def average_evaluations(self, n):\\n\\n assert(self.history_count > 0), \\\"not enough evaluations in average_evaluations!\\\"\\n\\n n = max(1, min(1000, n))\\n n = min(n, self.history_count)\\n # print(f'n = {n}')\\n # print(f'hist_cnt = {self.history_count}')\\n\\n sum_eval = 0.0\\n sum_theta = utils.linear_combinaison(0.0, self.theta0)\\n for i in range(n):\\n\\n j = ((self.history_count - 1) % 1000) - i\\n if j < 0:\\n j += 1000\\n if j >= 1000:\\n j -= 1000\\n\\n # print(f'i={i}, j={j}, hist_cnt: {self.history_count}, hist_eval[{j}] = {self.history_eval[j]}')\\n\\n sum_eval += self.history_eval[j]\\n sum_theta = utils.sum(sum_theta, self.history_theta[j])\\n\\n # return the average\\n alpha = 1.0 / (1.0 * n)\\n return (alpha * sum_eval, utils.linear_combinaison(alpha, sum_theta))\",\n \"def update_average(self,result):\\n a = 1/self.iters\\n b = 1 - a\\n self.average = a * result + b * self.average\\n self.iters += 1\",\n \"def average(num1, num2):\\n\\n return (num1 + num2) / 2\",\n \"def arithmetic_ret(self) -> float:\\n return float(np.log(self.tsdf).diff().mean() * self.periods_in_a_year)\",\n \"def average(entry):\\n return entry['total time (s)'] / float(entry['correct answers'] + entry['wrong answers'])\",\n \"def calculate_average_run_accuracy(self):\\n overall_true_rate, true_positive_rate, true_negative_rate, false_positive_rate, false_negative_rate, true_positive_rate_cutoff, true_negative_rate_cutoff, \\\\\\n false_positive_rate_cutoff, false_negative_rate_cutoff, unclassified_cutoff, matthews_correlation_coefficient, brier_score, auc_score, fit_time, hmeasure = [0] * 15\\n balanced_accuracy_arr = []\\n auc_arr = []\\n hmeasure_arr = []\\n brier_score_arr = []\\n fit_time_arr = []\\n mcc_arr = []\\n true_positive_arr = []\\n true_negative_arr = []\\n false_positive_arr = []\\n false_negative_arr = []\\n\\n count = 0\\n for result_dictionary in self.errors:\\n for z in range(len(result_dictionary[\\\"balanced_accuracy_arr\\\"])):\\n overall_true_rate += result_dictionary[\\\"balanced_accuracy_arr\\\"][z]\\n true_positive_rate += result_dictionary[\\\"true_positive_rate_arr\\\"][z]\\n true_negative_rate += result_dictionary[\\\"true_negative_rate_arr\\\"][z]\\n false_positive_rate += result_dictionary[\\\"false_positive_rate_arr\\\"][z]\\n false_negative_rate += result_dictionary[\\\"false_negative_rate_arr\\\"][z]\\n matthews_correlation_coefficient += result_dictionary[\\\"mcc_arr\\\"][z]\\n auc_score += result_dictionary[\\\"auc_arr\\\"][z]\\n brier_score += result_dictionary[\\\"brier_score_arr\\\"][z]\\n fit_time += result_dictionary[\\\"fit_time_arr\\\"][z]\\n hmeasure += result_dictionary[\\\"hmeasure_arr\\\"][z]\\n count += 1\\n\\n true_positive_rate_cutoff += result_dictionary[\\\"avg_true_positive_rate_with_prob_cutoff\\\"]\\n true_negative_rate_cutoff += result_dictionary[\\\"avg_true_negative_rate_with_prob_cutoff\\\"]\\n false_positive_rate_cutoff += result_dictionary[\\\"avg_false_positive_rate_with_prob_cutoff\\\"]\\n false_negative_rate_cutoff += result_dictionary[\\\"avg_false_negative_rate_with_prob_cutoff\\\"]\\n unclassified_cutoff += result_dictionary[\\\"avg_false_negative_rate_with_prob_cutoff\\\"]\\n balanced_accuracy_arr += result_dictionary[\\\"balanced_accuracy_arr\\\"]\\n hmeasure_arr += result_dictionary[\\\"hmeasure_arr\\\"]\\n auc_arr += result_dictionary[\\\"auc_arr\\\"]\\n brier_score_arr += result_dictionary[\\\"brier_score_arr\\\"]\\n fit_time_arr += result_dictionary[\\\"fit_time_arr\\\"]\\n mcc_arr += result_dictionary[\\\"mcc_arr\\\"]\\n true_positive_arr += result_dictionary[\\\"true_positive_rate_arr\\\"]\\n true_negative_arr += result_dictionary[\\\"true_negative_rate_arr\\\"]\\n false_positive_arr += result_dictionary[\\\"false_positive_rate_arr\\\"]\\n false_negative_arr += result_dictionary[\\\"false_negative_rate_arr\\\"]\\n\\n avg_run_results = [None] * 31\\n avg_run_results[0] = matthews_correlation_coefficient / float(count)\\n avg_run_results[1] = brier_score / float(count)\\n avg_run_results[2] = overall_true_rate / float(count)\\n avg_run_results[3] = true_positive_rate / float(count)\\n avg_run_results[4] = true_negative_rate / float(count)\\n avg_run_results[5] = false_positive_rate / float(count)\\n avg_run_results[6] = false_negative_rate / float(count)\\n avg_run_results[7] = true_positive_rate_cutoff / float(len(self.errors))\\n avg_run_results[8] = true_negative_rate_cutoff / float(len(self.errors))\\n avg_run_results[9] = false_positive_rate_cutoff / float(len(self.errors))\\n avg_run_results[10] = false_negative_rate_cutoff / float(len(self.errors))\\n avg_run_results[11] = unclassified_cutoff / float(len(self.errors))\\n avg_run_results[12] = fit_time / float(count)\\n avg_run_results[14] = balanced_accuracy_arr\\n avg_run_results[15] = auc_score / float(count)\\n avg_run_results[16] = auc_arr\\n avg_run_results[17] = brier_score_arr\\n avg_run_results[18] = fit_time_arr\\n avg_run_results[19] = mcc_arr\\n avg_run_results[13] = self.calculate_std_deviation(balanced_accuracy_arr)\\n avg_run_results[20] = self.calculate_std_deviation(mcc_arr)\\n avg_run_results[21] = self.calculate_std_deviation(brier_score_arr)\\n avg_run_results[22] = self.calculate_std_deviation(auc_arr)\\n avg_run_results[23] = self.calculate_std_deviation(fit_time_arr)\\n avg_run_results[24] = self.calculate_std_deviation(true_positive_arr)\\n avg_run_results[25] = self.calculate_std_deviation(true_negative_arr)\\n avg_run_results[26] = self.calculate_std_deviation(false_positive_arr)\\n avg_run_results[27] = self.calculate_std_deviation(false_negative_arr)\\n avg_run_results[28] = hmeasure / float(count)\\n avg_run_results[29] = self.calculate_std_deviation(hmeasure_arr)\\n avg_run_results[30] = hmeasure_arr\\n\\n return avg_run_results\",\n \"def _evaluate(self, estimator, generator):\\n return np.mean([np.mean(np.power(estimator.estimate(A, b) - x, 2))\\n for A, x, b in[generator.generate()\\n for _ in range(self.repetitions)]])\",\n \"def cal_average_kill_turns(deck):\\n #Results array\\n turn_results = np.zeros(NUM_SIMS)\\n \\n #Simulation loop\\n for i in range(NUM_SIMS): \\n if VERBOSE:\\n print('Running simulation ' + str(i + 1)) \\n turn_results[i] = cal_kill_turn(copy.deepcopy(deck))\\n #End of Simulations\\n \\n #DETERMINE ATK\\n average_kill_turn = np.average(turn_results)\\n min_kill_turn = np.min(turn_results)\\n max_kill_turn = np.max(turn_results)\\n \\n return average_kill_turn, min_kill_turn, max_kill_turn\",\n \"def average_reward(self):\\n T = len(self)\\n return np.sum(self.rewards / T)\",\n \"def getAverage(self):\\n return sum(self.scores) / len(self.scores)\",\n \"def average(grade1, grade2, grade3):\\n return (grade1 + grade2 + grade3) / 3\",\n \"def time_average(self, time_since_out, time_step):\\n\\n for variable in self._energy_state:\\n bar_variable = \\\"{}_bar\\\".format(variable)\\n bar_value = getattr(self, bar_variable)\\n ta = time_average(bar_value, time_since_out,\\n getattr(self, variable), time_step)\\n setattr(self, bar_variable, ta)\\n\\n self.E_s_sum += self.E_s\\n self.melt_sum += self.melt\\n self.swi_sum += self.swi\",\n \"def moving_average(position, step_size, avg_quantity):\\n print(\\\"1\\\")\\n avg_disp = int(math.floor(avg_quantity / 2))\\n start_frame = step_size + avg_disp + 1\\n end_frame = len(position) - avg_disp\\n moving_avg = []\\n for i in range(start_frame, end_frame + 1):\\n position_avg = 0\\n for j in range(i - 1 - avg_disp, i + avg_disp):\\n position_avg += position[j]\\n position_1 = position_avg / (avg_disp * 2 + 1)\\n \\n moving_avg.append(position_1)\\n print(\\\"2\\\")\\n return start_frame, end_frame, moving_avg\",\n \"def step(self, data: torch.Tensor) -> Tuple:\\r\\n image, _ = data\\r\\n image = image.to(self.device)\\r\\n batch_size = image.shape[0]\\r\\n label = torch.full(\\r\\n (batch_size,), self.label, dtype=torch.float, device=self.device\\r\\n )\\r\\n self.zero_grad()\\r\\n # Forward pass\\r\\n output = self(image).view(-1)\\r\\n # Calculate loss on a batch\\r\\n err = self.criterion(output, label)\\r\\n err.backward()\\r\\n avg_out = output.mean().item()\\r\\n self.optimizer.step()\\r\\n return avg_out\",\n \"def _determine_step(self):\\r\\n\\r\\n step_sizes = np.empty(len(self.h))\\r\\n\\r\\n for i in range(step_sizes.shape[0]):\\r\\n step_sizes[i] = np.mean(np.diff(self.h[i], n=1))\\r\\n\\r\\n return np.mean(step_sizes)\",\n \"def average(values):\\n return sum(values) / len(values)\",\n \"def average(values):\\n return sum(values) / len(values)\",\n \"def trial_atr(trial, omit_missing_frames=True):\\n frames = trial.HMM_MLE\\n if omit_missing_frames:\\n frames = frames[frames >= 0]\\n\\n runs = calc_run_lengths(trial.HMM_MLE)\\n return_times = []\\n current_return_time = 0\\n for run in runs:\\n if run.object == 0:\\n return_times.append(current_return_time/60)\\n current_return_time = 0\\n else:\\n current_return_time += run.length\\n return np.mean(return_times)\",\n \"def x_run_average_pipeline(num: int, language: str):\\n precision, recall, f1 = [], [], []\\n for i in range(num):\\n CRF = BaselineCRF(language)\\n predicted, labels = CRF.pipeline()\\n p, r, f = eval_morph_segments(predicted, labels)\\n precision.append(p)\\n recall.append(r)\\n f1.append(f)\\n\\n recall = sum(recall) / len(recall)\\n precision = sum(precision) / len(precision)\\n f1 = sum(f1) / len(f1)\\n return recall, precision, f1\",\n \"def average(values):\\n\\treturn sum(values)/len(values)\",\n \"def average(data, event):\\n if len(data) == 0:\\n return 0\\n\\n score = 0\\n # scores = []\\n count = 0\\n for i in data:\\n count += 1\\n if event == 'Swim' or event == 'Run':\\n num = time_seconds(i[event])\\n #print(\\\"first if\\\")\\n #Sprint(num)\\n else:\\n num = int(i[event])\\n #print(\\\"second if\\\")\\n #print(num)\\n #scores[count] =\\n #print(\\\"end of loop count\\\" + str(count))\\n score += num\\n #print (\\\"score\\\" + str(score))\\n\\n # total = 0\\n # for x in range(0,len(scores)):\\n # total += scores[x]\\n score = float(score)\\n\\n return score / count\",\n \"def result (result = None):\\n if result is not None:\\n results.append (float (result))\\n\\n if len (results) < self.min_count:\\n return None, None\\n\\n result_mean = functools.reduce (operator.add, results, 0) / len (results)\\n result_error = (functools.reduce (operator.add,\\n ((result - result_mean)**2 for result in results), 0) / (len (results) - 1))\\n return result_mean, result_error\",\n \"def average(self):\\n s = self.sum()\\n flat_shape = self.flatten_shape(self.shape)\\n num_of_elements = fct.reduce(opr.mul, flat_shape, 1)\\n average = s / num_of_elements\\n return average\",\n \"def avg(realizations, results):\\n avg_nmi, avg_snmi, avg_ari, avg_vi, avg_purity, avg_fmeasure = 0,0,0,0,0,0\\n for nmi, snmi, ari, vi, purity, f_measure in results:\\n avg_nmi += nmi\\n avg_snmi += snmi\\n avg_purity += purity\\n avg_fmeasure += f_measure\\n avg_vi += vi\\n avg_ari += ari\\n\\n return round(avg_nmi/realizations, 3), round(avg_snmi/realizations, 3), round(avg_ari/realizations, 3), round(avg_vi/realizations, 3), round(avg_purity/realizations, 3), round(avg_fmeasure/realizations, 3)\",\n \"def average(ls):\\n\\n if len(ls) == 0:\\n return 0.0\\n\\n sm = sum(ls)\\n return sm / len(ls)\",\n \"def get_average_repro(self):\\n return np.mean([agent.get_fledge_probability() for agent in self.agents])\",\n \"def calc_average(numbers):\\n return sum(numbers) // len(numbers) # integer division //\",\n \"def experiment(agent, steps, runs, initialize=None):\\n result = 0\\n for r in range(runs):\\n result += simulate(agent, steps, initialize)\\n return result / runs\",\n \"def avg_performance(env, policy):\\n\\n sum_reward = 0.\\n episode = 100\\n max_iteration = 6000\\n for i in range(episode):\\n done = False\\n ob = env.reset()\\n\\n for j in range(max_iteration):\\n a = policy[ob]\\n ob, reward, done, _ = env.step(a)\\n sum_reward += reward\\n if done:\\n break\\n\\n return sum_reward / i\",\n \"def calcAverage(dat):\\n return sum(dat)/len(dat)\",\n \"def em_mean(self) -> float:\\n if self.__total_pulls == 0:\\n raise Exception('Number of pulls is 0. No empirical mean.')\\n return self.__total_rewards / self.__total_pulls\",\n \"def get_avg_points(self):\\n pass\",\n \"def running_mean(sequence: list):\\n if not sequence:\\n return []\\n\\n mean = []\\n \\\"\\\"\\\"\\n [1] = 1 / 1\\n [1,2] = 3 / 2 \\n [1,2,3] = 6 / 3\\n \\\"\\\"\\\"\\n for idx, num in enumerate(sequence):\\n\\n sum_total = sum(sequence[:(idx + 1)])\\n result = sum_total / (idx + 1)\\n\\n mean.append(round(result, 2))\\n\\n return mean\",\n \"def calculate(self) -> float:\",\n \"def dishlist_avg_cal(n:list)->float:\\r\\n all_cal = dishlist_cal(n)\\r\\n return sum(all_cal)/len(all_cal)\",\n \"def avg_func(self, averaged_param: Tensor, source_param: Tensor,\\n steps: int) -> None:\\n averaged_param.mul_(1 - self.momentum).add_(\\n source_param, alpha=self.momentum)\",\n \"def make_averaged(fn, num_samples=1000):\\n # BEGIN PROBLEM 8\\n \\\"*** YOUR CODE HERE ***\\\"\\n def return_average(*args):\\n k, total = 0, 0\\n while k < num_samples:\\n total += fn(*args)\\n k += 1\\n return total / num_samples\\n return return_average\\n # END PROBLEM 8\",\n \"def compute_average(self, error=None):\\n\\n nbjobs = len(self)\\n if not nbjobs:\\n return\\n max_xsec = max(one.xsec for one in self)\\n min_xsec = min(one.xsec for one in self)\\n self.axsec = sum([one.axsec for one in self]) / nbjobs\\n self.xsec = sum([one.xsec for one in self]) /nbjobs\\n self.xerrc = sum([one.xerrc for one in self]) /nbjobs\\n self.xerru = math.sqrt(sum([one.xerru**2 for one in self])) /nbjobs\\n if error:\\n self.xerrc = error\\n self.xerru = error\\n\\n self.nevents = sum([one.nevents for one in self])\\n self.nw = 0#sum([one.nw for one in self])\\n self.maxit = 0#len(self.yerr_iter) # \\n self.nunwgt = sum([one.nunwgt for one in self]) \\n self.wgt = 0\\n self.luminosity = sum([one.luminosity for one in self])\\n self.ysec_iter = []\\n self.yerr_iter = []\\n self.th_maxwgt = 0.0\\n self.th_nunwgt = 0 \\n for result in self:\\n self.ysec_iter+=result.ysec_iter\\n self.yerr_iter+=result.yerr_iter\\n self.yasec_iter += result.yasec_iter\\n self.eff_iter += result.eff_iter\\n self.maxwgt_iter += result.maxwgt_iter\\n\\n #check full consistency\\n onefail = False\\n for one in list(self):\\n if one.xsec < (self.xsec - 25* one.xerru):\\n if not onefail:\\n logger.debug('multi run are inconsistent: %s < %s - 25* %s: assign error %s', one.xsec, self.xsec, one.xerru, error if error else max_xsec-min_xsec)\\n onefail = True\\n self.remove(one)\\n if onefail:\\n if error:\\n return self.compute_average(error)\\n else:\\n return self.compute_average((max_xsec-min_xsec)/2.)\",\n \"def moving_average(a, n=3) :\\n ret = np.cumsum(a, dtype=float)\\n ret[n:] = ret[n:] - ret[:-n]\\n return ret[n - 1:] / n\",\n \"def find_arithmetic_mean( *args):\\n sum = 0\\n for value in args:\\n sum += value\\n return sum/len(args)\",\n \"def average(self, n=0):\\n assert n >= 0\\n for key in self.value_history:\\n values = np.array(self.value_history[key][-n:])\\n nums = np.array(self.n_history[key][-n:])\\n avg = np.sum(values * nums) / np.sum(nums)\\n self.output[key] = avg\",\n \"def update(self,x): #update the estimate of rewards and number of esteps run\\n\\t\\tself.N += 1\\n\\t\\tself.estimate_mean = (1.0-1.0/self.N)*self.estimate_mean + (1.0/self.N)*x #recurence relation for averages\",\n \"def reduce_by_averaging(trials, total, amount):\\n new_averages = []\\n\\n for i in range(0, total):\\n if i % amount == 0:\\n new_averages.append(reduce(lambda x, y: x + y, trials[i:i+amount]) / \\\\\\n amount)\\n\\n return new_averages\",\n \"def moving_average(self, a, n=3):\\n ret = np.nancumsum(a, dtype=float)\\n ret[n:] = ret[n:] - ret[:-n]\\n return ret[n - 1:] / n\",\n \"def _ave(self):\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def get_avg(self) -> float:\\n if self._cur_elem_count < 1:\\n return 0\\n self._mtx.acquire()\\n avg = self._sum / float(self._cur_elem_count)\\n self._mtx.release()\\n return avg\",\n \"def _ave(self):\\n\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def get_average(self) -> float:\\n return sum(self._scores) / len(self._scores)\",\n \"def avg(x, y):\\n return (x + y)/2\",\n \"def average_grad(self):\\n\\n # Compute the respective gradients\\n grad_line_1 = self.gradient(0,1)\\n grad_line_2 = self.gradient(2,3)\\n\\n a1 = np.abs(np.arctan(grad_line_1))\\n a2 = np.abs(np.arctan(grad_line_2))\\n\\n ave_grad = np.tan((a1+a2)/2)\\n\\n #ave_grad = np.average([grad_line_1,grad_line_2]) # Compute the average gradient\\n\\n return ave_grad\",\n \"def average(cls, points):\\n return Point.sum(points) / len(points)\",\n \"def function2(a, b):\\r\\n average = (a + b) / 2\\r\\n return average\",\n \"def average(data):\\n return np.average(data)\",\n \"def stochastic_average(h, a, alpha, numsteps, numiter):\\n #Same times for all trajectories\\n times = zeros(numsteps+1)\\n trajectories = zeros((numiter, numsteps+1, 2))\\n\\n #Initial phase\\n phase = random.uniform(0, 1)\\n for i in range(numiter):\\n times, trajectories[i] = EulerInteg(h, a, alpha, numsteps, phase)\\n\\n stochastic_av = zeros((numsteps+1, 2))\\n for j in range(numsteps+1):\\n average_pos = array([0., 0.])\\n for k in range(numiter):\\n average_pos = average_pos + trajectories[k][j]\\n stochastic_av[j] = average_pos/numiter\\n\\n return times, stochastic_av\",\n \"def calculate(self):\\n self.results['max'] = numpy.max(self.data)\\n self.results['min'] = numpy.min(self.data)\\n if self.type == 0:\\n self.group_discrete_data()\\n if self.type == 1:\\n self.group_continuous_data()\\n\\n self.results['arithAvg'] = self.average([self.data[i] * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences)\\n self.results['quadAvg'] = math.sqrt(\\n self.average([(self.data[i] * self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences))\\n if self.results['min'] > 0:\\n self.results['geoAvg'] = math.exp(\\n self.average([numpy.log(self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences))\\n self.results['harmAvg'] = 1 / self.average(\\n [(self.occurrences[i] / self.data[i]) for i in range(len(self.data))],\\n self.totalOccurrences)\\n else:\\n self.results['geoAvg'] = self.results['harmAvg'] = \\\"N/A\\\"\\n self.results['momentsR'] = self.moments(self.data, self.occurrences, 4)\\n self.results['centralMomentsR'] = self.moments([(i - self.results['arithAvg']) for i in self.data],\\n self.occurrences, 4)\\n self.results['std'] = self.average(\\n [self.occurrences[i] * abs(self.data[i] - self.results['arithAvg']) for i in range(len(self.data))],\\n self.totalOccurrences)\",\n \"def get_average(data):\\n average = sum(data) / len(data)\\n\\n return average\",\n \"def average(self, times=2):\\n for i in range(times):\\n self.statistics()\\n global t, avlist\\n length = len(t)\\n avlist.append(t)\\n t = []\\n\\n total_list = []\\n\\n for l in range(length):\\n total_list.append([])\\n\\n for j in range(times):\\n \\\"\\\"\\\"per time\\\"\\\"\\\"\\n for i in range(length):\\n total_list[i].append(avlist[j][i])\\n\\n \\\"\\\"\\\"calculate\\\"\\\"\\\"\\n ylist = []\\n avlist = []\\n for a in total_list:\\n avg = 0\\n for b in a:\\n avg += b\\n ylist.append(avg/times)\\n self.listy = ylist\\n\\n for e in range(self.el[self.re[0]], self.re[1], self.re[2]):\\n self.listx.append(e)\",\n \"def average_energy(power,events,borders,eventName):\\n event_consider = events[events['eventName']==eventName].reset_index(drop=True)\\n average = 0\\n i = 0\\n count = 0\\n minValue = 10000\\n maxValue = 0\\n minAverage = 10000\\n maxAverage = 0 \\n while(i<len(event_consider)):\\n date = time.mktime(datetime.strptime(event_consider['time'][i], \\\"%Y-%m-%d %H:%M:%S\\\").timetuple())\\n start = str(datetime.fromtimestamp(date+borders[0]))\\n end = str(datetime.fromtimestamp(date+borders[1]))\\n values = power[(power['time']>=start)&(power['time']<=end)]['value']\\n sum_values = sum(values)\\n tot_values = len(values)\\n if tot_values>0:\\n if values.max() > maxValue:\\n maxValue = values.max()\\n if values.min() < minValue:\\n minValue = values.min()\\n if sum_values/tot_values > maxAverage:\\n maxAverage = sum_values/tot_values\\n if sum_values/tot_values < minAverage:\\n minAverage = sum_values/tot_values\\n average = average + sum_values/tot_values\\n count += 1\\n i += 1\\n if count>0:\\n average = average / count\\n print(\\\"number of\\\", eventName ,\\\"in groudtruth and power=\\\",count)\\n print(\\\"minValue=\\\",minValue,\\\"maxValue=\\\",maxValue)\\n print(\\\"minAverage=\\\",minAverage,\\\"maxAverage=\\\",maxAverage)\\n print(\\\"Final Av=\\\",average)\\n return average\\n else:\\n print(\\\"Not values found in the range\\\")\",\n \"def avg_hops(self):\\n return self._avg_hops\",\n \"def mrae(self, benchmark: np.ndarray = None):\\n return float(np.mean(np.abs(self._relative_error(benchmark))))\",\n \"def avg_func(self, averaged_param: Tensor, source_param: Tensor,\\n steps: int) -> None:\\n momentum = 1. - self.rampup(self.steps, self.ema_kimg, self.ema_rampup,\\n self.batch_size, self.eps)\\n if not (0.0 < momentum < 1.0):\\n warnings.warn('RampUp momentum must be in range (0.0, 1.0)'\\n f'but got {momentum}')\\n averaged_param.mul_(1 - momentum).add_(source_param, alpha=momentum)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7158892","0.6989263","0.6973302","0.68902016","0.67515194","0.6697132","0.652611","0.6519316","0.64798063","0.6475223","0.64444023","0.6367762","0.630979","0.6308836","0.62865496","0.62865496","0.62865496","0.62493414","0.61997265","0.61639595","0.6111974","0.6094934","0.6078407","0.6073247","0.60700184","0.6065695","0.6047945","0.60353243","0.60353243","0.602915","0.6002293","0.6001317","0.59916186","0.59915495","0.5986626","0.598014","0.59740007","0.5972205","0.59619","0.5960023","0.5959791","0.59481454","0.5943309","0.5942978","0.5941876","0.5940387","0.5938325","0.5933836","0.59255683","0.59066105","0.59054023","0.5902354","0.58936834","0.5889003","0.5887863","0.5887863","0.58848715","0.5878828","0.5865119","0.5861576","0.5854767","0.5848324","0.5846132","0.5840602","0.5840101","0.5829743","0.5814358","0.58067924","0.5804425","0.5803209","0.57964313","0.5796273","0.57930154","0.5788592","0.57859087","0.5785689","0.5769446","0.57651573","0.57552177","0.5752505","0.57429093","0.5741211","0.5740033","0.5736545","0.57320976","0.572973","0.5723657","0.57164687","0.5707752","0.5700289","0.56983435","0.5696938","0.56952375","0.569435","0.5690276","0.56887573","0.56876594","0.56845653","0.56829184","0.56810474"],"string":"[\n \"0.7158892\",\n \"0.6989263\",\n \"0.6973302\",\n \"0.68902016\",\n \"0.67515194\",\n \"0.6697132\",\n \"0.652611\",\n \"0.6519316\",\n \"0.64798063\",\n \"0.6475223\",\n \"0.64444023\",\n \"0.6367762\",\n \"0.630979\",\n \"0.6308836\",\n \"0.62865496\",\n \"0.62865496\",\n \"0.62865496\",\n \"0.62493414\",\n \"0.61997265\",\n \"0.61639595\",\n \"0.6111974\",\n \"0.6094934\",\n \"0.6078407\",\n \"0.6073247\",\n \"0.60700184\",\n \"0.6065695\",\n \"0.6047945\",\n \"0.60353243\",\n \"0.60353243\",\n \"0.602915\",\n \"0.6002293\",\n \"0.6001317\",\n \"0.59916186\",\n \"0.59915495\",\n \"0.5986626\",\n \"0.598014\",\n \"0.59740007\",\n \"0.5972205\",\n \"0.59619\",\n \"0.5960023\",\n \"0.5959791\",\n \"0.59481454\",\n \"0.5943309\",\n \"0.5942978\",\n \"0.5941876\",\n \"0.5940387\",\n \"0.5938325\",\n \"0.5933836\",\n \"0.59255683\",\n \"0.59066105\",\n \"0.59054023\",\n \"0.5902354\",\n \"0.58936834\",\n \"0.5889003\",\n \"0.5887863\",\n \"0.5887863\",\n \"0.58848715\",\n \"0.5878828\",\n \"0.5865119\",\n \"0.5861576\",\n \"0.5854767\",\n \"0.5848324\",\n \"0.5846132\",\n \"0.5840602\",\n \"0.5840101\",\n \"0.5829743\",\n \"0.5814358\",\n \"0.58067924\",\n \"0.5804425\",\n \"0.5803209\",\n \"0.57964313\",\n \"0.5796273\",\n \"0.57930154\",\n \"0.5788592\",\n \"0.57859087\",\n \"0.5785689\",\n \"0.5769446\",\n \"0.57651573\",\n \"0.57552177\",\n \"0.5752505\",\n \"0.57429093\",\n \"0.5741211\",\n \"0.5740033\",\n \"0.5736545\",\n \"0.57320976\",\n \"0.572973\",\n \"0.5723657\",\n \"0.57164687\",\n \"0.5707752\",\n \"0.5700289\",\n \"0.56983435\",\n \"0.5696938\",\n \"0.56952375\",\n \"0.569435\",\n \"0.5690276\",\n \"0.56887573\",\n \"0.56876594\",\n \"0.56845653\",\n \"0.56829184\",\n \"0.56810474\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75718766"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14895,"cells":{"query":{"kind":"string","value":"Collect game episode trajectories."},"document":{"kind":"string","value":"def collect_episode(environment, policy, num_episodes, replay_buffer_observer):\n initial_time_step = environment.reset()\n\n driver = py_driver.PyDriver(\n environment,\n py_tf_eager_policy.PyTFEagerPolicy(policy, use_tf_function=True),\n [replay_buffer_observer],\n max_episodes=num_episodes,\n )\n initial_time_step = environment.reset()\n driver.run(initial_time_step)"},"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 add(self, episodes: Union[List[\"_Episode\"], \"_Episode\"]):\n if isinstance(episodes, _Episode):\n episodes = [episodes]\n\n for eps in episodes:\n # Make sure we don't change what's coming in from the user.\n # TODO (sven): It'd probably be better to make sure in the EnvRunner to not\n # hold on to episodes (for metrics purposes only) that we are returning\n # back to the user from `EnvRunner.sample()`. Then we wouldn't have to\n # do any copying. Instead, either compile the metrics right away on the\n # EnvRunner OR compile metrics entirely on the Algorithm side (this is\n # actually preferred).\n eps = copy.deepcopy(eps)\n\n self._num_timesteps += len(eps)\n self._num_timesteps_added += len(eps)\n\n # Ongoing episode, concat to existing record.\n if eps.id_ in self.episode_id_to_index:\n eps_idx = self.episode_id_to_index[eps.id_]\n existing_eps = self.episodes[eps_idx - self._num_episodes_evicted]\n old_len = len(existing_eps)\n self._indices.extend([(eps_idx, old_len + i) for i in range(len(eps))])\n existing_eps.concat_episode(eps)\n # New episode. Add to end of our episodes deque.\n else:\n self.episodes.append(eps)\n eps_idx = len(self.episodes) - 1 + self._num_episodes_evicted\n self.episode_id_to_index[eps.id_] = eps_idx\n self._indices.extend([(eps_idx, i) for i in range(len(eps))])\n\n # Eject old records from front of deque (only if we have more than 1 episode\n # in the buffer).\n while self._num_timesteps > self.capacity and self.get_num_episodes() > 1:\n # Eject oldest episode.\n evicted_eps = self.episodes.popleft()\n evicted_eps_len = len(evicted_eps)\n # Correct our size.\n self._num_timesteps -= evicted_eps_len\n\n # Erase episode from all our indices:\n # 1) Main episode index.\n evicted_idx = self.episode_id_to_index[evicted_eps.id_]\n del self.episode_id_to_index[evicted_eps.id_]\n # 2) All timestep indices that this episode owned.\n new_indices = [] # New indices that will replace self._indices.\n idx_cursor = 0\n # Loop through all (eps_idx, ts_in_eps_idx)-tuples.\n for i, idx_tuple in enumerate(self._indices):\n # This tuple is part of the evicted episode -> Add everything\n # up until here to `new_indices` (excluding this very index, b/c\n # it's already part of the evicted episode).\n if idx_cursor is not None and idx_tuple[0] == evicted_idx:\n new_indices.extend(self._indices[idx_cursor:i])\n # Set to None to indicate we are in the eviction zone.\n idx_cursor = None\n # We are/have been in the eviction zone (i pointing/pointed to the\n # evicted episode) ..\n elif idx_cursor is None:\n # ... but are now not anymore (i is now an index into a\n # non-evicted episode) -> Set cursor to valid int again.\n if idx_tuple[0] != evicted_idx:\n idx_cursor = i\n # But early-out if evicted episode was only 1 single\n # timestep long.\n if evicted_eps_len == 1:\n break\n # Early-out: We reached the end of the to-be-evicted episode.\n # We can stop searching further here (all following tuples\n # will NOT be in the evicted episode).\n elif idx_tuple[1] == evicted_eps_len - 1:\n assert self._indices[i + 1][0] != idx_tuple[0]\n idx_cursor = i + 1\n break\n\n # Jump over (splice-out) the evicted episode if we are still in the\n # eviction zone.\n if idx_cursor is not None:\n new_indices.extend(self._indices[idx_cursor:])\n\n # Reset our `self._indices` to the newly compiled list.\n self._indices = new_indices\n\n # Increase episode evicted counter.\n self._num_episodes_evicted += 1","def _store_episode(self):\n # For each transition in the last episode,\n # create a set of artificial transitions\n for transition_idx, transition in enumerate(self.episode_transitions):\n\n obs_t, action, reward, obs_tp1, done, info = transition\n\n # Add to the replay buffer\n self.replay_buffer.add(obs_t, action, reward, obs_tp1, done)\n\n # We cannot sample a goal from the future in the last step of an episode\n if (transition_idx == len(self.episode_transitions) - 1 and\n self.goal_selection_strategy == GoalSelectionStrategy.FUTURE):\n break\n\n # Sampled n goals per transition, where n is `n_sampled_goal`\n # this is called k in the paper\n sampled_goals = self._sample_achieved_goals(self.episode_transitions, transition_idx)\n # For each sampled goals, store a new transition\n for goal in sampled_goals:\n # Copy transition to avoid modifying the original one\n obs, action, reward, next_obs, done, info = copy.deepcopy(transition)\n\n # Convert concatenated obs to dict, so we can update the goals\n obs_dict, next_obs_dict = map(self.env.convert_obs_to_dict, (obs, next_obs))\n\n # Update the desired goal in the transition\n obs_dict['desired_goal'] = goal\n next_obs_dict['desired_goal'] = goal\n\n # Update the reward according to the new desired goal\n reward = self.env.compute_reward(next_obs_dict['achieved_goal'], goal, info)\n # Can we use achieved_goal == desired_goal?\n done = False\n\n # Transform back to ndarrays\n obs, next_obs = map(self.env.convert_dict_to_obs, (obs_dict, next_obs_dict))\n\n # Add artificial transition to the replay buffer\n self.replay_buffer.add(obs, action, reward, next_obs, done)","def episodes(self):\n episodes = []\n for series in self.series:\n episodes.extend(series.episodes)\n return episodes","def on_episode_begin(self, episode, logs):\n self.episode_start[episode] = timeit.default_timer()\n self.observations[episode] = []\n self.rewards[episode] = []\n self.actions[episode] = []\n self.metrics[episode] = []","def on_episode_begin(self, episode, logs):\n self.episode_start[episode] = timeit.default_timer()\n self.observations[episode] = []\n self.rewards[episode] = []\n self.actions[episode] = []\n self.metrics[episode] = []","def episodes(self, num_episodes, num_steps_per_episode):\n for ep in range(num_episodes):\n self.start_episode()\n for step in range(num_steps_per_episode):\n next_sensation,reward = self.env(self.next_action)\n self.collect_data(self.last_sensation, self.next_action, reward, next_sensation)\n self.next_action = self.agent(next_sensation,reward)\n self.last_sensation = next_sensation\n if self.last_sensation == TERMINAL_STATE:\n break","def executeEpisode(self):\n trainExamples = []\n board = self.game.getInitBoard()\n self.curPlayer = 1\n episodeStep = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = self.game.getCanonicalForm(board, self.curPlayer)\n temp = int(episodeStep < self.args.tempThreshold)\n\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\n sym = self.game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, self.curPlayer, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n board, self.curPlayer = self.game.getNextState(board, self.curPlayer, action)\n\n r = self.game.getGameEnded(board, self.curPlayer)\n\n if r != 0:\n return [(x[0], x[2], r * ((-1) ** (x[1] != self.curPlayer))) for x in trainExamples]","def executeEpisode(self):\n trainExamples = []\n board = self.game.getInitBoard()\n self.curPlayer = 1\n episodeStep = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = self.game.getCanonicalForm(board, self.curPlayer)\n temp = int(episodeStep < self.args.tempThreshold)\n\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\n sym = self.game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, self.curPlayer, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n board, self.curPlayer = self.game.getNextState(board, self.curPlayer, action)\n\n r = self.game.getGameEnded(board, self.curPlayer)\n\n if r != 0:\n return [(x[0], x[2], r * ((-1) ** (x[1] != self.curPlayer))) for x in trainExamples]","def end_episode(self):\n self.training_buffer.reset_local_buffers()\n for agent_id in self.episode_steps:\n self.episode_steps[agent_id] = 0\n for rewards in self.collected_rewards.values():\n for agent_id in rewards:\n rewards[agent_id] = 0","def episodes(self):\n episodes = []\n for season in self.seasons:\n episodes.extend(season.episodes)\n return episodes","def executeEpisode(self):\n trainExamples = []\n board = self.game.getInitBoard()\n player = 1\n episodeStep = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = self.game.getCanonicalForm(board, player)\n temp = int(episodeStep < self.args.tempThreshold)\n\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\n sym = self.game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, player, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n board, player = self.game.getNextState(board, player, action)\n\n r = self.game.getGameEnded(board, player)\n\n if r != 0:\n ex = [(x[0], x[2], r * ((-1) ** (x[1] != player))) for x in trainExamples]\n return ex","def episode(agents, t, episode_nr):\n # Initialize E\n E = np.zeros((grid_size, grid_size), dtype = int) # Environment, i.e. the grid\n\n E[0][3] = 2 # Use for 10x10 grid\n E[1][3] = 2\n E[0][6] = 2\n E[1][6] = 2\n E[2][6] = 2\n E[7][3] = 2\n E[8][3] = 2\n E[9][3] = 2\n E[8][6] = 2\n E[9][6] = 2\n\n env_list.append(E)\n\n for agent in agents:\n agent.m = agent.start[0] # Initialize robot position\n agent.n = agent.start[1] # Initialize robot position\n E[agent.m][agent.n] = 1 # Initialize robot position on grid\n agent.carry = False # Initialize robot carry, i.e. the robot does NOT carry cargo\n agent.steps = 0 # Initialize number of steps taken during episode\n agent.reward = 0 # Do not reset if we should plot accumulated over all episodes\n agent.collisions = 0 # Reset number of collisions\n if episode_nr % 100 == 0:\n agent.save_target('target_weights_{}.h5'.format(agent.nr))\n agent.save_policy('policy_weights_{}.h5'.format(agent.nr))\n\n terminal = False # Terminal state has not been reached\n\n while not terminal: # While agents have not reached their terminal state\n E, terminal = iterate(agents, E, t, episode_nr)\n t += 1\n\n return t","def run_episode(self, environment):\n state, texts = environment.reset()\n self.steps_done = 0\n action = None\n while True:\n state_tensor = FloatTensor([state])\n text_tensor = FloatTensor(texts).mean(dim=0, keepdim=True)\n action = self.Q.sample_from_softmax_policy(state_tensor, text_tensor)\n position = self.convert_action(action)\n (next_state, next_texts), reward, done, _ = environment.step(position)\n next_text_tensor = FloatTensor(next_texts).mean(dim=0, keepdim=True)\n for t1 in texts:\n t1_tensor = FloatTensor([t1])\n for t2 in next_texts:\n t2_tensor = FloatTensor([t2])\n self.memory.push(\n (state_tensor, t1_tensor, action, t2_tensor,) # action is already a tensor\n )\n self.learn(state_tensor, text_tensor, action, next_state, next_text_tensor, reward)\n state = next_state\n self.steps_done += 1\n if done:\n break\n history = environment.close()\n return history","def run_all_episodes(self, episode_count):\n # Holds final result\n step_arr = []\n reward_arr = []\n new_abstr = {}\n detached_states = []\n\n if 'abstraction_type' in self.params.keys() and self.params['abstraction_type'] == 'discretization':\n self.agent.make_abstraction()\n\n while self.episode_count < episode_count:\n # Run episode, record results\n steps, reward = self.run_episode()\n step_arr.append(steps)\n reward_arr.append(reward)\n self.episode_count += 1\n if self.episode_count % 1 == 0:\n print('Episode {} finished with step count {}'.format(self.episode_count, steps))\n\n # Create temporal abstraction if applicable\n if 'make_abstraction' in self.params.keys() and self.episode_count in self.params['make_abstraction']:\n self.agent.make_abstraction()\n new_abstr = self.agent.params['s_a'].abstr_dict\n\n # Detach states if applicable\n if 'refine_abstraction' in self.params.keys() and self.episode_count in self.params['refine_abstraction']:\n newly_detached = self.agent.refine_abstraction()\n detached_states.extend(newly_detached)\n print('final abstraction')\n for i in range(len(self.agent.params['s_a'].cell_to_abstract_cell)):\n for key, value in self.agent.params['s_a'].cell_to_abstract_cell[i].items():\n print(key, value)\n\n return step_arr, reward_arr, new_abstr, detached_states","def executeEpisode(self, mcts, game, args):\n trainExamples = []\n board = game.getInitBoard()\n curPlayer = 1\n episodeStep = 0\n state_counter = Counter()\n\n moves = 0\n\n while True:\n episodeStep += 1\n canonicalBoard = game.getCanonicalForm(board, curPlayer)\n temp = int(episodeStep < self.args['tempThreshold'])\n\n pi = mcts.getActionProb(canonicalBoard, temp=temp)\n sym = game.getSymmetries(canonicalBoard, pi)\n for b, p in sym:\n trainExamples.append([b, curPlayer, p, None])\n\n action = np.random.choice(len(pi), p=pi)\n state_counter.update(game.stringRepresentation(board)) #count the visit to the board\n\n board, curPlayer = game.getNextState(board, curPlayer, action)\n\n r = game.getGameEnded(board, curPlayer)\n \n moves += 1\n\n if moves >= self.args['maxMoves']:\n r = 1e-4\n\n if r != 0:\n return ([(x[0], x[2], r * ((-1) ** (x[1] != curPlayer))) for x in trainExamples], state_counter)","def train_by_episode(self):\n # only REINFORCE and REINFORCE with baseline\n # use the ff code\n # convert the rewards to returns\n rewards = []\n gamma = 0.99\n for item in self.memory:\n [_, _, _, reward, _] = item\n rewards.append(reward)\n # rewards = np.array(self.memory)[:,3].tolist()\n\n # compute return per step\n # return is the sum of rewards from t til end of episode\n # return replaces reward in the list\n for i in range(len(rewards)):\n reward = rewards[i:]\n horizon = len(reward)\n discount = [math.pow(gamma, t) for t in range(horizon)]\n return_ = np.dot(reward, discount)\n self.memory[i][3] = return_\n\n # train every step\n for item in self.memory:\n self.train(item, gamma=gamma)","def on_episode_start(self, agent, **kwargs):\n self.episode_start[agent.brain.episode] = timeit.default_timer()\n self.observations[agent.brain.episode] = []\n self.rewards[agent.brain.episode] = []\n self.actions[agent.brain.episode] = []\n self.metrics[agent.brain.episode] = {}","def train(self):\n total_steps = 0\n scores_history = [deque(maxlen=self.run_settings.averaging_window)\n for a in range(len(self.agents))]\n averages_history = [[] for a in range(len(self.agents))]\n\n for e in range(self.run_settings.num_episodes):\n # Initialize episode\n try:\n env_states, rewards, done, metainfo = self.custom_env.reset()\n except EpisodeCrashException:\n for a in range(len(self.agents)):\n if hasattr(self.agents[a], 'notify_episode_crashed'):\n self.agents[a].notify_episode_crashed(self.run_settings)\n continue\n\n # Initialize scores to starting reward (probably 0)\n scores = rewards\n step = 0\n\n while not done:\n states = [self.agents[a].state_space_converter(env_states[a])\n for a in range(len(self.agents))]\n\n # Train agents\n if total_steps > 0 and total_steps % self.run_settings.train_every == 0:\n for agent in self.agents:\n agent.train(self.run_settings)\n\n # Save agent model\n if total_steps > 0 and total_steps % self.run_settings.save_every == 0:\n for agent in self.agents:\n agent.save()\n\n # Get actions\n actions = [self.agents[a].sample(states[a])\n for a in range(len(self.agents))]\n env_actions = [self.agents[a].action_space_converter(actions[a])\n for a in range(len(self.agents))]\n # Take environment step\n try:\n env_states, rewards, done, metainfo = self.custom_env.step(env_actions)\n except EpisodeCrashException:\n for a in range(len(self.agents)):\n if hasattr(self.agents[a], 'notify_episode_crashed'):\n self.agents[a].notify_episode_crashed(self.run_settings)\n break\n step += 1\n total_steps += 1\n\n # Update scores\n scores = [scores[a] + rewards[a] for a in range(len(self.agents))]\n # Push to agent Memories\n for a in range(len(self.agents)):\n self.agents[a].push_memory(states[a], actions[a], rewards[a], done)\n\n if done:\n averages = []\n for a in range(len(scores_history)):\n scores_history[a].append(scores[a])\n averages.append(np.mean(scores_history[a]))\n averages_history[a].append(averages[a])\n\n if len(scores) == 1:\n scores = scores[0]\n averages = averages[0]\n if self.run_settings.verbose:\n print(\"Game {} ended after {} steps. Game score: {}. Averages: {}\"\n .format(e+1, step, scores, averages))\n if (self.run_settings.graph_every > 0 and e > 0\n and e % self.run_settings.graph_every == 0):\n self.plot_results(averages_history)","def run_episode(self, environment):\n state = environment.reset()\n self.steps_done = 0\n while True:\n state_tensor = FloatTensor([state])\n position = self.Q.sample_from_softmax_policy(state_tensor)\n action = position + 1\n next_state, reward, done, _ = environment.step(position.item())\n self.memory.push((state_tensor, action,))\n self.learn(state_tensor, action, next_state, reward)\n state = next_state\n self.steps_done += 1\n if done:\n break\n history = environment.close()\n return history","def test(self):\n total_steps = 0\n running_scores = np.zeros(len(self.agents))\n\n for e in range(self.run_settings.test_episodes):\n # Initialize episode\n try:\n env_states, rewards, done, metainfo = self.custom_env.reset()\n except EpisodeCrashException:\n print('Episode crashed, resetting.')\n continue\n\n # Initialize scores to starting reward (probably 0)\n scores = np.array(rewards)\n step = 0\n\n while not done:\n states = [self.agents[a].state_space_converter(env_states[a])\n for a in range(len(self.agents))]\n\n # Get actions\n actions = [self.agents[a].sample(states[a])\n for a in range(len(self.agents))]\n env_actions = [self.agents[a].action_space_converter(actions[a])\n for a in range(len(self.agents))]\n if self.run_settings.verbose:\n self.print_action(env_actions)\n # Take environment step\n try:\n env_states, rewards, done, metainfo = self.custom_env.step(env_actions)\n except EpisodeCrashException:\n print('Episode crashed, resetting.')\n break\n step += 1\n total_steps += 1\n\n # Update scores\n scores += np.array(rewards)\n\n if done:\n running_scores += scores\n\n if len(scores) == 1:\n scores = scores[0]\n if self.run_settings.verbose:\n print(\"Game {} ended after {} steps. Game score: {}\"\n .format(e+1, step, scores))\n if self.run_settings.verbose:\n print(\"Average game scores: {}\".format(running_scores / self.run_settings.test_episodes))","def add_episode(self, ep):\n #make da season\n ses = self._add_season(ep)\n dvdses = self._add_season(ep, dvd=True) \n self._add_episode(ep, ses)\n self._add_episode(ep, dvdses, dvd=True)","def on_episode_end(self, agent, **kwargs):\n episode = agent.brain.episode\n duration = timeit.default_timer() - self.episode_start[episode]\n episode_steps = len(self.observations[episode])\n\n # Format all metrics.\n metrics = self.metrics[episode]\n\n nb_step_digits = str(int(np.ceil(np.log10(self.nb_steps))) + 1)\n template = '{step: ' + nb_step_digits + 'd}/{nb_steps}: episode: {episode}, duration: {duration: 5.3f}s, episode steps: {episode_steps: 5d}, steps per second: {sps: 5.0f}, episode reward: {episode_reward: 10.3f}, mean reward: {reward_mean: 7.3f} [{reward_min: 10.3f}, {reward_max: 10.3f}], mean action: {action_mean: 5.3f} [{action_min: 5.3f}, {action_max: 5.3f}], mean observation: {obs_mean: 5.3f} [{obs_min: 5.3f}, {obs_max: 5.3f}], {metrics}'\n variables = {\n 'step': self.step,\n 'nb_steps': self.nb_steps,\n 'episode': episode + 1,\n 'duration': duration,\n 'episode_steps': episode_steps,\n 'sps': float(episode_steps) / duration,\n 'episode_reward': np.sum(self.rewards[episode]),\n 'reward_mean': np.mean(self.rewards[episode]),\n 'reward_min': np.min(self.rewards[episode]),\n 'reward_max': np.max(self.rewards[episode]),\n 'action_mean': np.mean(self.actions[episode]),\n 'action_min': np.min(self.actions[episode]),\n 'action_max': np.max(self.actions[episode]),\n 'obs_mean': np.mean(self.observations[episode]),\n 'obs_min': np.min(self.observations[episode]),\n 'obs_max': np.max(self.observations[episode]),\n 'metrics': \", \".join([\"{}: {: 10.3f}\".format(metrics_key, np.mean(metrics_values))\n for metrics_key, metrics_values in metrics.items()]),\n }\n print(template.format(**variables))\n\n # Free up resources.\n del self.episode_start[episode]\n del self.observations[episode]\n del self.rewards[episode]\n del self.actions[episode]\n del self.metrics[episode]","def RunEpisode(env, policy, eps):\n\n obs = env.reset()\n memory = []\n R = 0\n for t in range(1000):\n action = policy(obs.astype('float32').reshape(1, 4))[0]\n# pdb.set_trace()\n r = np.random.rand()\n if r<eps:\n action = np.random.random_integers(0,1, ()).tolist()\n\n new_obs, reward, done, info = env.step(action)\n memory.append((obs, action, new_obs, reward, done))\n obs = new_obs\n if done:\n break\n\n return memory","def run_episode(self, deterministic=False):\n\n\n obs = self.env.reset()\n Observations, Actions, Rewards = [], [], [] # original trajectory\n n_Observations, n_Rewards = [], [] # normalized trajectory\n done = False\n timestep = 0\n while not done and timestep < self.episode_horizon:\n Observations.append(obs)\n if self.state_preprocessor:\n n_obs = self.state_preprocessor.get_scaled_x(obs)\n else:\n n_obs = obs\n n_Observations.append(n_obs)\n action = self.policy.get_action(obs.astype(np.float32).reshape((1,-1)), deterministic=deterministic)\n Actions.append(action.flatten())\n obs, reward, done, _ = self.env.step(np.squeeze(action, axis=0))\n Rewards.append(reward)\n if self.reward_preprocessor:\n n_reward = self.reward_preprocessor.get_scaled_x(reward)\n else:\n n_reward = reward\n n_Rewards.append(n_reward)\n timestep += 1\n\n \n # append the last state\n Observations.append(obs)\n if self.state_preprocessor:\n n_obs = self.state_preprocessor.get_scaled_x(obs)\n else:\n n_obs = obs\n n_Observations.append(n_obs)\n\n unscaled_traj = {\"Observations\": np.array(Observations), \"Actions\": np.array(Actions), \"Rewards\": np.array(Rewards)}\n scaled_traj = {\"Observations\": np.array(n_Observations), \"Actions\": np.array(Actions), \"Rewards\": np.array(n_Rewards)}\n\n # update preprocessers\n if self.state_preprocessor:\n self.state_preprocessor.update(unscaled_traj['Observations'])\n # save preprocessor params for restoration\n self.state_preprocessor.save_params(os.path.join(self.logger.info_dir, \"state_preprocessor_params.pkl\"))\n if self.reward_preprocessor:\n self.reward_preprocessor.update(unscaled_traj['Rewards'])\n self.reward_preprocessor.save_params(os.path.join(self.logger.info_dir, \"reward_preprocessor_params.pkl\"))\n \n return unscaled_traj, scaled_traj","def collect_episode_batch(policy, *,\n env,\n batch_size,\n n_workers=4):\n sampler = get_sampler(policy, env=env, n_workers=n_workers)\n agent_update = policy.get_param_values()\n episodes = sampler.obtain_samples(0, batch_size, agent_update)\n return episodes","def run_episode(env, agent, deterministic, do_training=True, rendering=False, max_timesteps=1000):\n\n stats = EpisodeStats() # save statistics like episode reward or action usage\n state = env.reset()\n\n step = 0\n while True:\n\n action_id = agent.act(state=state, deterministic=deterministic)\n next_state, reward, terminal, info = env.step(action_id)\n\n if do_training:\n agent.train(state, action_id, next_state, reward, terminal)\n\n state = next_state\n\n # # NOTE reward shaping...\n # if terminal:\n # reward += -1\n # if step < 20:\n # reward += -10\n # if step > 100:\n # reward += 10\n\n stats.step(reward, action_id)\n\n if rendering:\n env.render()\n\n if terminal or step > max_timesteps:\n break\n\n step += 1\n\n return stats","def _get_episodes(self):\n return [series_episode for series_episode in SeriesEpisode.objects.filter(series=self)]","def _end_episode(self):\n self.turn_cnt = 0\n self.episode_cnt += 1\n self.contexts = None\n self.seed_utterances = None\n self.reset_agents()","def episode(self, n):\n rewards = []\n for i in range(n):\n self.episode_n += 1\n self.state = self.env.reset()\n self.agent.new_episode(self.state)\n self.total_reward = 0.0\n t = 0\n for t in range(self.max_episode_len):\n terminate = self.step()\n if terminate:\n break\n logging.warning(\"Episode %d finished after %d steps, total reward=%f\", self.episode_n, t+1,\n self.total_reward)\n summary = tf.Summary()\n summary.value.add(tag=\"episode_total_reward\", simple_value=self.total_reward)\n summary.value.add(tag=\"epsisode_success\", simple_value=self.flag_success)\n self.summary_writer.add_summary(summary, self.episode_n)\n rewards.append(self.total_reward)\n if self.savedir is not None:\n self.steps_saver.end_save()\n return rewards","def record_episode(env: Env, policy: Policy, max_steps=10000) -> List[Interaction]:\n episode = []\n obs = env.reset()\n\n for i in range(max_steps):\n action = policy.choose_action(obs)\n next_obs, reward, done, _ = env.step(action)\n episode.append(Interaction(obs, action, reward))\n if done:\n return episode\n obs = next_obs\n raise Exception(\"Episode did not terminate.\")","def generate_episode(env, args, render=False, test_mode=False):\n episode = []\n state, done = env.reset(), False\n observations = transform_obs(env.get_all_observations())\n n_steps = 0\n\n for agent in env.agents: # for agents where it matters,\n agent.set_hidden_state() # set the init hidden state of the RNN\n\n while not done:\n unavailable_actions = env.get_unavailable_actions()\n \n # compute action, keep record of hidden state of the agents to store in experience\n actions, hidden, next_hidden = {}, [], []\n for idx, agent in enumerate(env.agents):\n hidden.append(agent.get_hidden_state())\n actions[agent] = agent.act(observations[idx, :], test_mode=test_mode)\n next_hidden.append(agent.get_hidden_state())\n\n if render:\n print(f\"Step {n_steps}\")\n env.render()\n print([action.name for action in actions.values()])\n\n next_state, rewards, done, _ = env.step(actions)\n next_obs = transform_obs(env.get_all_observations())\n \n # episodes that take long are not allowed and penalized for both agents\n n_steps += 1\n if n_steps > args.max_episode_length:\n done = True\n rewards = {'blue': -1, 'red': -1}\n\n actions = torch.tensor([action.id for action in actions.values()])\n unavail_actions = torch.zeros((args.n_agents, args.n_actions), dtype=torch.long)\n for idx, agent in enumerate(env.agents):\n act_ids = [act.id for act in unavailable_actions[agent]]\n unavail_actions[idx, act_ids] = 1.\n \n episode.append(Experience(transform_state(state), actions, rewards, \n transform_state(next_state), done, \n observations, torch.stack(hidden), \n next_obs, torch.stack(next_hidden),\n unavail_actions))\n \"\"\"\n episode.append(Experience(None, actions, rewards, \n None, done, \n observations, torch.stack(hidden), \n next_obs, torch.stack(next_hidden),\n unavail_actions))\n \"\"\" \n state = next_state\n observations = next_obs\n \n if render:\n print(f\"Game won by team {env.terminal(next_state)}\")\n return episode","def inspect(self, save_imgs=True):\n if 'data' in self.path:\n outdir = (self.path).replace('data/', 'data_out/')\n elif 'goals' in self.path:\n outdir = (self.path).replace('goals/', 'goals_out/')\n if os.path.exists(outdir):\n import shutil\n print(f'Removing: {outdir}')\n shutil.rmtree(outdir)\n os.makedirs(outdir)\n print(f'Saving to: {outdir}')\n print(f'episode_set: {self.episode_set}')\n print(f'num_episodes: {self.num_episodes}')\n\n def _load(i_ep, episode_len, field):\n field_path = os.path.join(self.path, field)\n fname = f'{i_ep:06d}-{episode_len}.pkl'\n return pickle.load(open(os.path.join(field_path, fname), 'rb'))\n\n # For data analysis later to evalute demonstrator quality. Anything for\n # 'maxlen_stats' should only be applied on episodes with max length.\n ep_lengths = []\n all_stats = defaultdict(list)\n maxlen_stats = defaultdict(list)\n\n for i_ep in range(self.num_episodes):\n if i_ep % 20 == 0:\n print(f'\\ton episode {i_ep}')\n\n # is_episode_sample: list of [F,F,T,T,F,F,..], T for this epis only.\n is_episode_sample = np.int32(self.episode_id) == i_ep\n episode_samples = np.argwhere(is_episode_sample).squeeze().reshape(-1)\n episode_len = len(episode_samples)\n ep_lengths.append(episode_len)\n color_l = _load(i_ep, episode_len, 'color')\n depth_l = _load(i_ep, episode_len, 'depth')\n info_l = _load(i_ep, episode_len, 'info')\n\n # Save images if desired, but can take a lot of time.\n if save_imgs:\n self._save_images(episode_len, color_l, depth_l, info_l, outdir, i_ep)\n\n # ---------------------------------------------------------------- #\n # If we have 'last' info, we should use it. Should apply to any\n # data generated on August 12 or later. As of Aug 28, I changed it\n # so `last_info` will save everything in the `info`, NOT just the\n # 'extras' key (needed for goal conditioning).\n # ---------------------------------------------------------------- #\n if not os.path.exists(os.path.join(self.path, 'last_info')):\n continue\n last_color = _load(i_ep, episode_len, 'last_color')\n last_depth = _load(i_ep, episode_len, 'last_depth')\n last_info = _load(i_ep, episode_len, 'last_info')\n\n # Add stuff to `ep_` lists.\n self._track_data_statistics(info_l, last_info, episode_len,\n all_stats, maxlen_stats)\n\n if save_imgs:\n # See transporter.py, mirroring Transporter.get_heightmap().\n obs_input = {'color': last_color, 'depth': last_depth}\n colormap, heightmap = get_heightmap(obs_input)\n heightmap_proc = process_depth(img=heightmap)\n\n # Same as earlier, fusing images together.\n c_img_front = last_color[0] # Shape (480, 640, 3)\n c_img_front = cv2.resize(c_img_front, (426,320)) # numpy shape: (320,426)\n barrier = np.zeros((320,4,3)) # Black barrier of 4 pixels\n combo = np.concatenate((\n cv2.cvtColor(c_img_front, cv2.COLOR_BGR2RGB),\n barrier,\n cv2.cvtColor(colormap, cv2.COLOR_RGB2BGR),\n barrier,\n heightmap_proc),\n axis=1)\n\n # Optionally include title with more details, but env dependent.\n suffix_all = f'{i_ep:06d}-{episode_len:02d}-FINAL.png'\n suffix_all = self._change_name(suffix_all, last_info['extras'])\n cv2.imwrite(os.path.join(outdir,suffix_all), combo)\n # ---------------------------------------------------------------- #\n\n # Debugging / inspection. First, debug all episodes.\n max_l = get_max_episode_len(self.path)\n ep_lengths = np.array(ep_lengths)\n print(f'\\nStats over {self.num_episodes} demos:')\n print(f'ep len avg: {np.mean(ep_lengths):0.3f} +/- {np.std(ep_lengths):0.1f}')\n print(f'ep len median: {np.median(ep_lengths):0.3f}')\n print(f'ep len min/max: {np.min(ep_lengths)}, {np.max(ep_lengths)}')\n num_max = np.sum(ep_lengths == max_l)\n print(f'ep equal to max len ({max_l}): {num_max} / {self.num_episodes}')\n print('You can approximate this as failures, but might overcount).\\n')\n\n # Consider env-specific properties, prefacing with [maxlen] as needed.\n # Though we'll get NaNs if no episodes got to the max -- but thats OK. :)\n print('Now environment-specific statistics:')\n\n if 'cable-shape' in self.path or 'cable-line-notarget' in self.path:\n # For these tasks, I want to see performance as a function of nb_sides.\n low, high = 1, 1 # for cable-line-notarget (one side only)\n if 'cable-shape' in self.path:\n low, high = 2, 4\n for nb_sides in range(low, high + 1):\n md = maxlen_stats[f'done_{nb_sides}']\n mf = maxlen_stats[f'frac_{nb_sides}']\n ad = all_stats[f'done_{nb_sides}']\n af = all_stats[f'frac_{nb_sides}']\n al = all_stats[f'len_{nb_sides}']\n print(f'[maxlen] {nb_sides}_done: {np.sum(md)} / {len(md)}')\n print(f'[maxlen] {nb_sides}_frac: {np.mean(mf):0.3f} +/- {np.std(mf):0.1f}')\n print(f'[alleps] {nb_sides}_done: {np.sum(ad)} / {len(ad)}')\n print(f'[alleps] {nb_sides}_frac: {np.mean(af):0.3f} +/- {np.std(af):0.1f}')\n print(f'[alleps] {nb_sides}_len: {np.mean(al):0.2f} +/- {np.std(al):0.1f}\\n')\n\n elif 'cable-ring' in self.path:\n # A bit tricky to interpret area, so I am using percentage improvement.\n md = maxlen_stats['done']\n mf = maxlen_stats['fraction']\n mf_c = maxlen_stats['fraction_delta']\n ma_pi = maxlen_stats['percent_improve']\n ad = all_stats['done']\n af = all_stats['fraction']\n af_c = all_stats['fraction_delta']\n aa_pi = all_stats['percent_improve']\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\n print(f'[maxlen] fraction: {np.mean(mf):0.3f} +/- {np.std(mf):0.1f}')\n print(f'[maxlen] f-delta: {np.mean(mf_c):0.3f} +/- {np.std(mf_c):0.1f}')\n print(f'[maxlen] % area: {np.mean(ma_pi):0.3f} +/- {np.std(ma_pi):0.1f}')\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\n print(f'[alleps] fraction: {np.mean(af):0.3f} +/- {np.std(af):0.1f}')\n print(f'[alleps] f-delta: {np.mean(af_c):0.3f} +/- {np.std(af_c):0.1f}')\n print(f'[alleps] % area: {np.mean(aa_pi):0.3f} +/- {np.std(aa_pi):0.1f}')\n\n elif 'cloth-flat' in self.path:\n # Report coverage deltas for `cloth-flat` and `cloth-flat-notarget`.\n md = maxlen_stats['done']\n mc = maxlen_stats['cloth_coverage']\n mc_d = maxlen_stats['coverage_delta']\n ad = all_stats['done']\n ac = all_stats['cloth_coverage']\n ac_d = all_stats['coverage_delta']\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\n print(f'[maxlen] cov-final: {np.mean(mc):0.3f} +/- {np.std(mc):0.1f}')\n print(f'[maxlen] cov-delta: {np.mean(mc_d):0.3f} +/- {np.std(mc_d):0.1f}')\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\n print(f'[alleps] cov-final: {np.mean(ac):0.3f} +/- {np.std(ac):0.1f}')\n print(f'[alleps] cov-delta: {np.mean(ac_d):0.3f} +/- {np.std(ac_d):0.1f}')\n\n elif 'cloth-cover' in self.path:\n # As of Aug 12, this env should have all rollouts with 2 actions.\n md = maxlen_stats['done']\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\n\n elif 'bag-alone-open' in self.path:\n # Similar to cable-ring.\n md = maxlen_stats['done']\n mf = maxlen_stats['fraction']\n mf_c = maxlen_stats['fraction_delta']\n ma_pi = maxlen_stats['percent_improve']\n ad = all_stats['done']\n af = all_stats['fraction']\n af_c = all_stats['fraction_delta']\n aa_pi = all_stats['percent_improve']\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\n print(f'[maxlen] fraction: {np.mean(mf):0.3f} +/- {np.std(mf):0.1f}')\n print(f'[maxlen] f-delta: {np.mean(mf_c):0.3f} +/- {np.std(mf_c):0.1f}')\n print(f'[maxlen] % area: {np.mean(ma_pi):0.3f} +/- {np.std(ma_pi):0.1f}')\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\n print(f'[alleps] fraction: {np.mean(af):0.3f} +/- {np.std(af):0.1f}')\n print(f'[alleps] f-delta: {np.mean(af_c):0.3f} +/- {np.std(af_c):0.1f}')\n print(f'[alleps] % area: {np.mean(aa_pi):0.3f} +/- {np.std(aa_pi):0.1f}')\n\n elif 'bag-items-easy' in self.path or 'bag-items-hard' in self.path:\n # Unlike other tasks, here we already did heavy data filtering beforehand.\n md = maxlen_stats['done']\n m_ts = maxlen_stats['task_stage']\n m_zi = maxlen_stats['zone_items_rew']\n m_zb = maxlen_stats['zone_beads_rew']\n ad = all_stats['done']\n a_ts = all_stats['task_stage']\n a_zi = all_stats['zone_items_rew']\n a_zb = all_stats['zone_beads_rew']\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\n print(f'[maxlen] task_stage: {np.mean(m_ts):0.3f} +/- {np.std(m_ts):0.1f}')\n print(f'[maxlen] zone_items: {np.mean(m_zi):0.3f} +/- {np.std(m_zi):0.1f}')\n print(f'[maxlen] zone_beads: {np.mean(m_zb):0.3f} +/- {np.std(m_zb):0.1f}')\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\n print(f'[alleps] task_stage: {np.mean(a_ts):0.3f} +/- {np.std(a_ts):0.1f}')\n print(f'[alleps] zone_items: {np.mean(a_zi):0.3f} +/- {np.std(a_zi):0.1f}')\n print(f'[alleps] zone_beads: {np.mean(a_zb):0.3f} +/- {np.std(a_zb):0.1f}')\n\n elif 'bag-color-goal' in self.path:\n # Also does data filtering beforehand.\n md = maxlen_stats['done']\n m_ts = maxlen_stats['task_stage']\n m_th = maxlen_stats['frac_in_target_bag']\n m_dh = maxlen_stats['frac_in_distract_bag']\n ad = all_stats['done']\n a_ts = all_stats['task_stage']\n a_th = all_stats['frac_in_target_bag']\n a_dh = all_stats['frac_in_distract_bag']\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\n print(f'[maxlen] task_stage: {np.mean(m_ts):0.3f} +/- {np.std(m_ts):0.1f}')\n print(f'[maxlen] frac_target_bag: {np.mean(m_th):0.3f} +/- {np.std(m_th):0.1f}')\n print(f'[maxlen] frac_distract_bag: {np.mean(m_dh):0.3f} +/- {np.std(m_dh):0.1f}')\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\n print(f'[alleps] task_stage: {np.mean(a_ts):0.3f} +/- {np.std(a_ts):0.1f}')\n print(f'[alleps] frac_target_bag: {np.mean(a_th):0.3f} +/- {np.std(a_th):0.1f}')\n print(f'[alleps] frac_distract_bag: {np.mean(a_dh):0.3f} +/- {np.std(a_dh):0.1f}')","def episode_to_transitions_pose_toy(episode_data):\n # This is just saving data for a supervised regression problem, so obs_tp1\n # can be discarded.\n transitions = []\n for transition in episode_data:\n (obs_t, action, reward, obs_tp1, done, debug) = transition\n del obs_tp1\n del done\n features = {}\n obs_t = Image.fromarray(obs_t)\n features['state/image'] = _bytes_feature([image.jpeg_string(obs_t)])\n features['pose'] = _float_feature(action.flatten().tolist())\n features['reward'] = _float_feature([reward])\n features['target_pose'] = _float_feature(debug['target_pose'].tolist())\n transitions.append(\n tf.train.Example(features=tf.train.Features(feature=features)))\n return transitions","def end_episode(self):\n self.training_buffer.reset_all()\n for agent_id in self.cumulative_rewards:\n self.cumulative_rewards[agent_id] = 0\n for agent_id in self.episode_steps:\n self.episode_steps[agent_id] = 0\n if self.use_curiosity:\n for agent_id in self.intrinsic_rewards:\n self.intrinsic_rewards[agent_id] = 0","def stopEpisode(self):\n if self.episodesSoFar < self.numTraining:\n self.accumTrainRewards += self.episodeRewards\n else:\n self.accumTestRewards += self.episodeRewards\n self.episodesSoFar += 1\n if self.episodesSoFar >= self.numTraining:\n # Take off the training wheels\n self.epsilon = 0.0 # no exploration\n self.alpha = 0.0 # no learning\n\n print(\"Agent Stop Episode\")\n print(self.episodeRewards)\n for feature, weight in self.weights.iteritems():\n print(\"\\t\" + str(feature) + \" - \" + str(weight))\n self.episodeRewardsList.append(self.episodeRewards)","def q_learning(env, agent, num_episodes, batch_size, epsilon, epsilon_min, epsilon_decay, folder):\n \n # Keeps track of useful statistics\n stats = plotting.EpisodeStats(\n episode_lengths=np.zeros(num_episodes),\n episode_rewards=np.zeros(num_episodes))\n\n\n for i_episode in range(num_episodes):\n if epsilon > epsilon_min and i_episode > 500:\n # complete random exploration 500 episodes, \n # then decrase exploration till epsilon less than epsilon_min\n epsilon *= epsilon_decay\n sys.stdout.flush()\n\n state = env.reset()\n state = np.reshape(state, [1, env.nS])\n\n \n for t in range(MAX_STEP):\n\n ## Decide action\n action = agent.act(state, epsilon)\n ## Advance the game to the next frame based on the action\n next_state, reward, done, _ = env.step(action)\n\n env.my_render(folder)\n\n stats.episode_rewards[i_episode] += reward\n stats.episode_lengths[i_episode] = t+1\n\n next_state = np.reshape(next_state, [1, env.nS])\n ## Remember the previous state, action, reward, and done\n agent.remember(state, action, reward, next_state, done)\n ## make next_state the new current state for the next frame.\n state = next_state ## change to copy.copy(next_state), if it is a array\n\n if len(agent.memory) > batch_size:\n agent.replay(batch_size) \n\n if done: \n break\n \n mean_score = stats.episode_rewards[i_episode]/stats.episode_lengths[i_episode]\n print(\"episode: {}/{}, score: {}, e: {:.2}, steps:{}, mean score:{:.2}\"\n .format(i_episode, num_episodes, stats.episode_rewards[i_episode], epsilon, \n stats.episode_lengths[i_episode], \n mean_score))\n #if(i_episode > 200):\n write_csv(folder, i_episode, stats.episode_lengths[i_episode], mean_score)\n if(i_episode%50 == 0):\n agent.save(folder + \"_qn\" + str(i_episode) + \".h5\") \n agent.save(folder + \"_qn-final\" + \".h5\") \n\n return stats","def train_episode(self):\n state = self.env.reset()\n states = []\n actions = []\n rewards = []\n for _ in range(self.options.steps):\n probs = self.actor_baseline.predict([[state]])[0][0]\n action = np.random.choice(len(probs), p=probs)\n\n next_state, reward, done, _ = self.step(action)\n states.append(state)\n actions.append(action)\n rewards.append(reward)\n\n state = next_state\n\n if done:\n break\n\n # Compute and store returns in G\n G = np.zeros_like(rewards)\n ################################\n # YOUR IMPLEMENTATION HERE #\n ################################\n\n # One-hot encoding for actions\n actions_one_hot = np.zeros([len(actions), self.env.action_space.n])\n actions_one_hot[np.arange(len(actions)), actions] = 1\n\n # Compute one-hot encoded deltas\n ################################\n # YOUR IMPLEMENTATION HERE #\n ################################\n deltas = [[0]]\n\n # Update actor and state estimator\n self.actor_baseline.fit(x=[np.array(states)],\n y={'actor_output': deltas, 'baseline_output': returns},\n epochs=1, batch_size=self.options.batch_size, verbose=0)","def episodes(self):\n if self._episode_cache_ver == self._db._version:\n return self._episode_cache\n\n # Get only rows from the preferred provider (provider id is not null) except\n # for season 0 (specials), where we take all episodes.\n if self.number > 0:\n idmap = {self.series.provider.IDATTR: db.QExpr('>', u'')}\n else:\n idmap = {}\n dbrows = self._db.query(type='episode', parent=self.series._dbrow, season=self.number, **idmap)\n self._episode_cache = [Episode(self._db, self.series, self, dbrow) for dbrow in dbrows]\n self._episode_cache.sort(key=lambda e: e.number)\n self._episode_cache_ver = self._db._version\n return self._episode_cache","def get_all(self):\n # s = torch.FloatTensor(self._states).to(device)\n # a = torch.FloatTensor(self._actions).to(device)\n # r = torch.FloatTensor(self._rewards).to(device)\n return self._episodes","def run_episode(env, agent, deterministic, skip_frames=0, do_training=True, rendering=True, max_timesteps=10000,\n history_length=0, manual=False):\n\n stats = utils.EpisodeStats()\n\n # Save history\n image_hist = []\n\n step = 0\n state = env.reset()\n\n env.viewer.window.on_key_press = utils.key_press\n env.viewer.window.on_key_release = utils.key_release\n # fix bug of corrupted states without rendering in gym environment\n env.viewer.window.dispatch_events()\n\n # append image history to first state\n state = state_preprocessing(state)\n image_hist.extend([state] * (history_length + 1))\n state = np.array(image_hist).reshape(96, 96, history_length + 1)\n while True:\n #skip intro zoom frames\n if step < 48:\n step += 1\n env.step(utils.id_to_action(0))\n continue\n \n # TODO: get action_id from agent\n # Hint: adapt the probabilities of the 5 actions for random sampling so that the agent explores properly.\n if do_training and manual:\n action_id = utils.manual_action\n else:\n action_id = agent.act(state, deterministic)\n action = utils.id_to_action(action_id)\n\n # Hint: frame skipping might help you to get better results.\n reward = 0\n for _ in range(skip_frames + 1):\n next_state, r, terminal, info = env.step(action)\n reward += r\n\n if rendering:\n env.render()\n\n if terminal:\n break\n\n next_state = state_preprocessing(next_state)\n \n image_hist.append(next_state)\n image_hist.pop(0)\n next_state = np.array(image_hist).reshape(96, 96, history_length + 1)\n\n if do_training and (next_state[:82, :, -1].sum() > 5000): #track out of sight\n print('Track gone; finish this episode')\n agent.add(state, action_id, next_state, reward=-(skip_frames + 1), terminal=True) #punish\n break\n\n if do_training:\n agent.add(state, action_id, next_state, reward, terminal)\n if not manual:\n agent.train()\n\n stats.step(reward, action_id)\n\n state = next_state\n \n if terminal or (step * (skip_frames + 1)) > max_timesteps:\n break\n\n step += 1\n\n return stats","def run(self) -> None:\n for episode in range(1, self.episodes + 1):\n print('Episode:', episode)\n steps, state_action_history = self.run_one_episode()\n self.steps_per_episode.append(steps)\n if episode % parameters.CACHING_INTERVAL == 0 or steps < 1000:\n visualize.animate_track(state_action_history, f'agent-{episode}')\n\n print('Training completed.')\n visualize.plot_steps_per_episode(self.steps_per_episode)\n visualize.plot_epsilon(self.agent.epsilon_history)\n\n if parameters.VISUALIZE_FINAL_GAME:\n print('Showing one episode with the greedy strategy.')\n self.agent.epsilon = 0\n steps, state_action_history = self.run_one_episode()\n print(f'Episode completed in {steps} steps.')\n visualize.animate_track(state_action_history)","def collect(self) -> int:\n self.get_logger().info('Generating experiences...')\n # Decay epsilon if requred\n self._wp.decay_epsilon(self.episode, 0.001)\n\n # Generate experiences\n trajectory_length, total_reward = self.step()\n self.publish(total_reward)\n self.flag.shift_to_compute_cycle()\n\n # Total reward section\n self._total_reward += total_reward\n if (self.episode + 1) % self._update == 0:\n self.get_logger().error(\n f'Expected Reward: {self._total_reward / self._update}')\n self._total_reward = 0\n\n return trajectory_length","def train_on_history(self, history):\n \n # Split into episodes\n n_episodes = history[-1][\"episode\"] \n episodes = [list(filter(lambda h: h[\"episode\"]==e , history)\n ) for e in range(n_episodes)\n ]\n\n # Split into game lives\n for episode in episodes:\n \n \n game_lives = [\n list(filter(lambda h: h.get('info').get('ale.lives')==l, episode)\n ) for l in range(5)\n ]\n \n for life in game_lives:\n if life:\n self.train(life)\n else:\n print(\"No ocurrance\")\n return","def run(agent, env, num_episodes = 20000, mode = 'train'):\n\t scores=[]\n\t max_avg_score=-np.inf\n\t for i_episode in range(1, num_episodes + 1):\n\t # Initialize episode\n\t state=env.reset()\n\t action=agent.reset_episode(state)\n\t total_reward=0\n\t done=False\n\n\t # Roll out steps until done\n\t while not done:\n\t state, reward, done, info=env.step(action)\n\t total_reward += reward\n\t action=agent.act(state, reward, done, mode)\n\n\t # Save final score\n\t scores.append(total_reward)\n\n\t # Print episode stats\n\t if mode == 'train':\n\t if len(scores) > 100:\n\t avg_score=np.mean(scores[-100:])\n\t if avg_score > max_avg_score:\n\t max_avg_score=avg_score\n\n\t if i_episode % 100 == 0:\n\t print(\"\\rEpisode {}/{} | Max Average Score: {}\".format(i_episode,\n\t num_episodes, max_avg_score), end = \"\")\n\t sys.stdout.flush()\n\n\t return scores\n\n\tscores=run(q_agent, env)\n\n\t# Plot scores obtained per episode\n\tplt.plot(scores); plt.title(\"Scores\")\n\n\tdef plot_scores(scores, rolling_window = 100):\n\t\t\"\"\"Plot scores and optional rolling mean using specified window.\"\"\"\n\t\tplt.plot(scores); plt.title(\"Scores\");\n\t\trolling_mean=pd.Series(scores).rolling(rolling_window).mean()\n\t\tplt.plot(rolling_mean);\n\t\treturn rolling_mean\n\n\trolling_mean=plot_scores(scores)\n\n\t# Run in test mode and analyze socres obtained\n\ttest_scores=run(q_agent, env, num_episodes = 100, mode = 'test')\n\tprint(\"[TEST] Completed {} episodes with avg. score = {}\".format(\n\t len(test_scores), np.mean(test_scores)))\n\t_=plot_scores(test_scores, rolling_window = 10)\n\n\n\tdef plot_q_table(q_table):\n \"\"\"Visualize max Q-value for each state and corresponding action.\"\"\"\n\t q_image=np.max(q_table, axis = 2) # max Q-value for each state\n\t q_actions=np.argmax(q_table, axis = 2) # best action for each state\n\n\t fig, ax=plt.subplots(figsize = (10, 10))\n\t cax=ax.imshow(q_image, cmap = 'jet');\n\t cbar=fig.colorbar(cax)\n\t for x in range(q_image.shape[0]):\n\t for y in range(q_image.shape[1]):\n\t ax.text(x, y, q_actions[x, y], color = 'white',\n\t horizontalalignment = 'center', verticalalignment = 'center')\n\t ax.grid(False)\n\t ax.set_title(\"Q-table, size: {}\".format(q_table.shape))\n\t ax.set_xlabel('position')\n\t ax.set_ylabel('velocity')\n\n\n\tplot_q_table(q_agent.q_table)\n\n\n\tstate_grid_new=create_uniform_grid(\n\t env.observation_space.low, env.observation_space.high, bins = (20, 20))\n\tq_agent_new=QLearningAgent(env, state_grid_new)\n\tq_agent_new.scores=[]\n\n\n\tq_agent_new.scores += run(q_agent_new, env,\n\t num_episodes = 50000) # accumulate scores\n\trolling_mean_new=plot_scores(q_agent_new.scores)\n\n\ttest_scores= run(q_agent_new, env, num_episodes = 100, mode = 'test')\n\tprint(\"[TEST] Completed {} episodes with avg. score = {}\".format(\n\t len(test_scores), np.mean(test_scores)))\n\t_=plot_scores(test_scores)\n\n\tplot_q_table(q_agent_new.q_table)\n\n\tstate=env.reset()\n\tscore=0\n\timg=plt.imshow(env.render(mode='rgb_array'))\n\tfor t in range(1000):\n\t\taction=q_agent_new.act(state, mode = 'test')\n\t\timg.set_data(env.render(mode='rgb_array'))\n\t\tplt.axis('off')\n\t\tdisplay.display(plt.gcf())\n\t\tdisplay.clear_output(wait = True)\n\t\tstate, reward, done, _=env.step(action)\n\t\tsocre += reward\n\t\tif done:\n\t\t\tprint('Score: ', socre)\n\t\t\tbreak\n\tenv.close()","def __getitem__(self, cur_episode):\n if self.platform == \"win\":\n env = lmdb.open(self.lmdb_file, subdir=False,\n readonly=True, lock=False,\n readahead=False, meminit=False)\n else:\n env = self.env\n # episode_set = self.episode_sets[episode]\n total_support_x = []\n total_query_x = []\n total_support_y = []\n total_query_y = []\n\n for t in range(self.t_task):\n # create a task (n_way*k_shot+ n_way*k_query)\n\n support_x = []\n query_x = []\n support_y = []\n query_y = []\n\n support_imgs = []\n query_imgs = []\n\n # select n_way classes randomly\n selected_classes = np.random.choice(self.total_cls, self.n_way)\n # select k_shot + k_query for each class\n for selected_class in selected_classes:\n selected_imgs = np.random.choice(\n self.dic_img_label[self.num2label[selected_class]], self.k_shot + self.k_query, False)\n support_imgs += selected_imgs[:self.k_shot].tolist()\n query_imgs += selected_imgs[self.k_shot:].tolist()\n\n with env.begin(write=False) as txn:\n for i, img_id in enumerate(support_imgs):\n res = pyarrow.deserialize(txn.get(u'{}'.format(img_id).encode('ascii')))\n support_x.append(self.transform(res[0]))\n support_y.append(np.array([self.label2num[res[1]]]))\n\n for i, img_id in enumerate(query_imgs):\n res = pyarrow.deserialize(txn.get(u'{}'.format(img_id).encode('ascii')))\n query_x.append(self.transform(res[0]))\n query_y.append(np.array([self.label2num[res[1]]]))\n support_x = torch.stack(support_x, 0)\n query_x = torch.stack(query_x, 0)\n support_y = np.array(support_y)\n query_y = np.array(query_y)\n\n # shuffle:\n index = np.random.permutation(len(support_y))\n support_x = support_x[index]\n if not self.fet_global:\n support_y = np.array([i for i in range(self.n_way) for j in range(self.k_shot)])\n support_y = support_y[index]\n\n index = np.random.permutation(len(query_y))\n query_x = query_x[index]\n if not self.fet_global:\n query_y = np.array([i for i in range(self.n_way) for j in range(self.k_query)])\n\n query_y = query_y[index]\n\n # a batch\n total_query_x.append(query_x)\n total_query_y.append(query_y)\n total_support_x.append(support_x)\n total_support_y.append(support_y)\n\n total_query_x = torch.cat(total_query_x, 0)\n total_query_y = np.hstack(total_query_y)\n total_support_x = torch.cat(total_support_x, 0)\n total_support_y = np.hstack(total_support_y)\n\n imgs = torch.cat([total_support_x, total_query_x], 0)\n labels = torch.from_numpy(np.hstack([total_support_y, total_query_y]).reshape([-1, 1]))\n return imgs, labels","def process_results(self, episode, eval):\n if episode % 10 == 9:\n ave = np.mean(self.scores[episode - 9:episode])\n print('Episodes: {}, AveScores: {}, Alpha: {}, Steps: {}'.format(\n episode + 1, ave, self.alpha.item(), self.step_count))\n if eval:\n if episode % 100 == 99:\n s1 = './' + self.game_name + '/'\n np.save(s1 + 'scores_eval{}.npy'.format(episode + 1), self.scores)\n print('Evaluation results saved!')\n else:\n if episode % 200 == 199:\n self.save_episode_models(episode)\n self.plot_array(episode)\n print('Model salved!')\n print('Total {} frames!'.format(self.frames_count))","def on_episode_end(self, episode, logs):\n duration = timeit.default_timer() - self.episode_start[episode]\n episode_steps = len(self.observations[episode])\n\n metrics = np.array(self.metrics[episode])\n metrics_dict = {}\n with warnings.catch_warnings():\n warnings.filterwarnings('error')\n for idx, name in enumerate(self.metrics_names):\n try:\n metrics_dict[name] = np.nanmean(metrics[:, idx])\n except Warning:\n metrics_dict[name] = float('nan')\n\n wandb.log(\n {\n 'step': self.step,\n 'episode': episode + 1,\n # 'duration': duration,\n 'episode_steps': episode_steps,\n # 'sps': float(episode_steps) / duration,\n 'episode_reward_sum': np.sum(self.rewards[episode]),\n 'reward_mean': np.mean(self.rewards[episode]),\n 'reward_min': np.min(self.rewards[episode]),\n 'reward_max': np.max(self.rewards[episode]),\n 'action_mean': np.mean(self.actions[episode]),\n # 'action_min': np.min(self.actions[episode]),\n # 'action_max': np.max(self.actions[episode]),\n # 'obs_mean': np.mean(self.observations[episode]),\n # 'obs_min': np.min(self.observations[episode]),\n # 'obs_max': np.max(self.observations[episode]),\n 'steps': logs['steps'],\n 'target_reached': logs['target_reached'],\n 'target_reached_in_steps': logs['target_reached_in_steps'],\n 'episode_reward': logs['episode_reward'],\n **metrics_dict\n }\n )\n\n # Free up resources.\n del self.episode_start[episode]\n del self.observations[episode]\n del self.rewards[episode]\n del self.actions[episode]\n del self.metrics[episode]","def episodes(self):\n for episode in self._root.iter('Episode'):\n entry = {}\n entry['season'] = int(episode.find('SeasonNumber').text)\n entry['episode'] = int(episode.find('EpisodeNumber').text)\n entry['title'] = unicode(episode.find('EpisodeName').text)\n if entry['title'] == '':\n continue\n entry['description'] = unicode(episode.find('Overview').text)\n entry['firstAired'] = episode.find('FirstAired').text\n yield entry","def on_step_end(self, step, logs):\n episode = logs['episode']\n self.observations[episode].append(logs['observation'])\n self.rewards[episode].append(logs['reward'])\n self.actions[episode].append(logs['action'])\n self.metrics[episode].append(logs['metrics'])\n self.step += 1","def on_step_end(self, step, logs):\n episode = logs['episode']\n self.observations[episode].append(logs['observation'])\n self.rewards[episode].append(logs['reward'])\n self.actions[episode].append(logs['action'])\n self.metrics[episode].append(logs['metrics'])\n self.step += 1","def run(self):\n data_provider = DataProvider(self.config)\n hex_attr_df = data_provider.read_hex_bin_attributes()\n hex_distance_df = data_provider.read_hex_bin_distances()\n city_states = data_provider.read_city_states(self.city_states_filename)\n neighborhood = data_provider.read_neighborhood_data()\n popular_bins = data_provider.read_popular_hex_bins()\n num_episodes = self.config['RL_parameters']['num_episodes']\n ind_episodes = self.config['RL_parameters']['ind_episodes']\n exp_decay_multiplier = self.config['RL_parameters']['exp_decay_multiplier']\n\n q_ind = None\n r_table = None\n xi_matrix = None\n\n best_episode = None\n best_model = {}\n\n progress_bar = tqdm(xrange(num_episodes))\n for episode_id in progress_bar:\n progress_bar.set_description(\"Episode: {}\".format(episode_id))\n current_best = -1000000\n\n # Create episode\n ind_exploration_factor = np.e ** (-1 * episode_id * exp_decay_multiplier / ind_episodes)\n\n episode = Episode(self.config,\n episode_id,\n ind_exploration_factor,\n hex_attr_df,\n hex_distance_df,\n city_states,\n neighborhood,\n popular_bins,\n q_ind,\n r_table,\n xi_matrix)\n\n # Run episode\n tables = episode.run()\n q_ind = tables['q_ind']\n r_table = tables['r_table']\n xi_matrix = tables['xi_matrix']\n episode_tracker = tables['episode_tracker']\n\n # Uncomment for logging if running a job, comment during experiments\n # otherwise it leads to insanely huge logging output which is useless\n\n # self.logger.info(\"\"\"\n # Expt: {} Episode: {} Earnings: {}\n # Pax rides: {} Relocation rides: {} Unmet demand: {}\n # \"\"\".format(self.expt_name, episode_id,\n # episode_tracker.gross_earnings,\n # episode_tracker.successful_waits,\n # episode_tracker.relocation_rides,\n # episode_tracker.unmet_demand))\n # self.logger.info(\"----------------------------------\")\n\n self.training_tracker.update_RL_tracker(\n episode_id, episode_tracker.gross_earnings,\n episode_tracker.successful_waits, episode_tracker.unsuccessful_waits,\n episode_tracker.unmet_demand, episode_tracker.relocation_rides,\n episode_tracker.DET, episode_tracker.DPRT, episode_tracker.DWT,\n episode_tracker.DRT, episode_tracker.DCT)\n\n # Keep track of the best episode\n if self.objective == 'revenue':\n if episode_tracker.gross_earnings >= current_best:\n best_episode = episode_tracker\n current_best = best_episode.gross_earnings\n else: # self.objective == 'pickups':\n if episode_tracker.successful_waits >= current_best:\n best_episode = episode_tracker\n current_best = episode_tracker.successful_waits\n\n # Keep track of the best model\n best_model['ind_exploration_factor'] = ind_exploration_factor\n best_model['config'] = self.config\n best_model['q_ind'] = q_ind\n best_model['r_table'] = r_table\n best_model['xi_matrix'] = xi_matrix\n best_model['training_tracker'] = self.training_tracker\n\n # After finishing training\n self.logger.info(\"Expt: {} Earnings: {} Met Demand: {} Unmet Demand: {}\".format(self.expt_name,\n best_episode.gross_earnings,\n best_episode.successful_waits,\n best_episode.unmet_demand))\n return best_episode, best_model, self.training_tracker","def ddpg(n_episodes=1000, print_every=50):\r\n \r\n scores = []\r\n scores_deque = deque(maxlen=print_every)\r\n log = open(\"log.txt\",\"w+\")\r\n for i_episode in range(1, n_episodes+1):\r\n env_info = env.reset(train_mode=True)[BRAIN_NAME]\r\n agent.reset()\r\n state = env_info.vector_observations # get the current state\r\n score = np.zeros(NUM_AGENTS)[:, None] \r\n \r\n while True:\r\n action = agent.act(state) # select an action\r\n env_info = env.step(action)[BRAIN_NAME] # send the action to the environment\r\n next_state = env_info.vector_observations # get the next state\r\n reward = np.array(env_info.rewards)[:, None] # get the reward\r\n done = np.array(env_info.local_done )[:, None] # see if episode has finished\r\n agent.step(state, action, reward, next_state, done) # take step with agent (including learning)\r\n score += reward # update the score\r\n state = next_state # roll over the state to next time step\r\n if np.any(done): \r\n break\r\n scores_deque.append(score.mean()) \r\n scores.append(score.mean()) \r\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)), end=\"\")\r\n if i_episode % print_every == 0:\r\n string ='\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque))\r\n print(string)\r\n log.write(string)\r\n torch.save(agent.actor_local.state_dict(), 'checkpoint_actor.pth')\r\n torch.save(agent.critic_local.state_dict(), 'checkpoint_critic.pth')\r\n \r\n if np.mean(scores_deque)>=30.0 and i_episode>=100:\r\n print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)))\r\n torch.save(agent.actor_local.state_dict(), 'checkpoint_actor.pth')\r\n torch.save(agent.critic_local.state_dict(), 'checkpoint_critic.pth')\r\n break\r\n log.close()\r\n return scores","def run_episode(self):\n self.pygame_clock = pygame.time.Clock()\n while True:\n pygame.event.pump()\n is_human_agent = isinstance(self.agents[self.env.turn], HumanAgent)\n\n # handle exit event\n self.handle_input_event()\n\n # pick the next action\n if is_human_agent:\n self.handle_input_event()\n else:\n self.ai_event()\n self.place_a_disk()\n self.render()\n\n if self.event == Event.END_GAME:\n pygame.time.wait(self.END_GAME_DELAY)\n\n if self.event == Event.END_GAME_VIEW:\n pygame.time.wait(self.END_GAME_VIEW_DELAY)\n break","def _rollout_an_episode(self):\n self._steps = 0\n me_id = self._learning_agent_id # short name\n oppo_id = self._oppo_agent_id # short name\n logger.log('episode begins with the task: {}'.format(str(self.task)))\n\n # passing me and oppo hyperparams to the arena interface\n assert self.task.hyperparam is not None\n logger.log('pulling oppo hyperparam of model key {}'.format(\n self.task.model_key2))\n oppo_hyperparam = self._model_pool_apis.pull_attr(attr='hyperparam',\n key=self.task.model_key2)\n logger.log('Done pulling oppo hyperparam')\n oppo_inter_kwargs = ({} if oppo_hyperparam is None\n else oppo_hyperparam.__dict__)\n inter_kwargs = ([self.task.hyperparam.__dict__]\n + [oppo_inter_kwargs] * (self.n_agents - 1))\n\n # agent, env reset\n obs = self.env.reset(inter_kwargs=inter_kwargs)\n for agt, ob in zip(self.agents, obs):\n agt.reset(ob)\n self._update_agents_model(self.task) # for agent Neural Net parameters\n\n me_reward_sum = 0.0\n self.time_beg = time.time()\n self._update_hyperparam(self.task)\n self._changed_task = False\n while True:\n self._steps += 1\n # predictions for each agent\n predictions = self._parallel.run((self._agent_pred, ob, i)\n for i, ob in enumerate(obs))\n me_prediction = predictions[me_id]\n me_action, extra_vars = me_prediction[me_id], me_prediction[oppo_id:]\n # predicted actions for each agent\n actions = [me_action] + [other_action\n for other_action in predictions[oppo_id:]]\n # book-keep obs in previous step\n last_obs = obs\n\n # agent-env interaction\n obs, reward, done, info = self.env.step(actions)\n\n me_rwd_scalar = self._reward_shape(reward[me_id])\n me_reward_sum += me_rwd_scalar\n\n if self._enable_push:\n # put the interested data (obs, rwd, act, ... for each agent) into the\n # _data_queue, which is watched in another Thread (the _push_data_to_learner()\n # method) that the data are dequeued and sent to remote Learner\n if self._data_queue.full():\n logger.log(\"Actor's queue is full.\", level=logger.WARN)\n rwd_to_push = (me_rwd_scalar if self.rwd_shape\n else np.asarray(reward[me_id], np.float32))\n if self.use_oppo_obs:\n if isinstance(extra_vars, tuple):\n extra_vars += (self.agents[self._oppo_agent_id]._last_state,)\n else:\n extra_vars.append(self.agents[self._oppo_agent_id]._last_state)\n data_tuple = (last_obs, tuple(actions), rwd_to_push, info, done, extra_vars)\n self._data_queue.put(data_tuple)\n logger.log('successfully put one tuple.', level=logger.DEBUG)\n\n if self._steps % self._log_interval_steps == 0:\n logger.log('_rollout_an_episode,', 'steps: {},'.format(self._steps),\n 'data qsize: {}'.format(self._data_queue.qsize()))\n\n if done:\n # an episode ends\n if self._replay_dir:\n self._save_replay()\n self.log_kvs(me_reward_sum, info)\n if self._changed_task:\n return None, info\n else:\n return self.log_outcome(info), info\n\n if self._update_model_freq and self._steps % self._update_model_freq == 0:\n # time to update the model for each agent\n if (self._enable_push and\n self._model_pool_apis.pull_attr(\n 'freezetime', self.task.model_key1) is not None):\n # Current task (learning period) finishes, start a new task or continue\n self._finish_task(self.task, None) # notify early abort\n last_task = self.task\n self.task = self._request_task() # try to continue\n if not is_inherit(last_task.model_key1, self.task.model_key1):\n self.log_kvs(me_reward_sum, info)\n return None, info\n if last_task.model_key2 != self.task.model_key2:\n self._changed_task = True\n self._update_agents_model(self.task)","def evolve(self, env, num_generations, num_episodes, num_frames):\n for gen in range(num_generations):\n\n if Trainer.VERBOSE:\n print(\"Generation:\", gen)\n\n # Generate new root Teams\n self.generation()\n\n # Evaluate current agents\n self.evaluation(env, num_episodes, num_frames)\n\n # Perform selection\n self.selection()\n\n # Return to top-performing agent. Typically not used, but nice to have\n ranked_agents = sorted(self.agent_pop, key=lambda rt : rt.team.fitness, reverse=True)\n return ranked_agents[0]","def train(self, env):\n\n\t\tmin_average_reward_for_stopping = 195\n\t\tconsecutive_successful_episodes_to_stop = 10\n\t\tlast_10_rewards = deque(maxlen=consecutive_successful_episodes_to_stop)\n\n\t\tnum_Episodes = []\n\t\tEpisode_Rewards = []\n\n\t\tfor episode in range(self.episodes):\n\t\t\tstate = env.reset()\n\t\t\tstate = np.reshape(state, [1, self.state_size])\n\t\t\tdone = False\n\t\t\ttotal_reward = 0\n\n\t\t\twhile not done:\n\t\t\t\taction = self.act(state)\n\t\t\t\tnext_state, reward, done, _ = env.step(action)\n\t\t\t\tnext_state = np.reshape(next_state, [1, self.state_size])\n\t\t\t\tself.remember(state, action, reward, next_state, done)\n\t\t\t\tstate = next_state\n\t\t\t\ttotal_reward += reward\n\n\t\t\tnum_Episodes.append(episode)\n\t\t\tEpisode_Rewards.append(total_reward)\n\t\t\tlast_10_rewards.append(total_reward)\n\t\t\tlast_10_avg_reward = np.mean(last_10_rewards)\n\t\t\tprint(episode, last_10_avg_reward)\n\n\t\t\t# call experience relay\n\t\t\tif len(self.memory) >= self.batch_size:\n\t\t\t\tself.replay(self.batch_size)\n\t\t\t# Stopping criteria\n\t\t\tif len(\n\t\t\t\t\tlast_10_rewards) == consecutive_successful_episodes_to_stop \\\n\t\t\t\t\tand last_10_avg_reward > min_average_reward_for_stopping:\n\t\t\t\tprint(\"Solved after {} epsiodes\".format(episode))\n\t\t\t\tbreak","def get_traj(agent, env, episode_max_length):\n # MARK: changed\n\n env.reset()\n obs = []\n acts = []\n rews = []\n entropy = []\n info = []\n machines = []\n ob = env.observe()\n\n for _ in range(episode_max_length):\n\n act_prob = agent.get_action(ob)\n machine_prob = agent.get_machine(ob)\n # csprob_n = np.cumsum(act_prob)\n # a = (csprob_n > np.random.rand()).argmax()\n # print(act_prob)\n ob = ob.reshape(ob.shape[0]*ob.shape[1])\n obs.append(ob) # store the ob at current decision making step\n acts.append(act_prob)\n machines.append(machine_prob)\n ob, rew, done, info = env.step(act_prob,machine_prob, repeat=True)\n\n rews.append(rew)\n\n entropy.append(get_entropy(act_prob))\n if done: break\n return {'reward': np.array(rews),\n 'ob': np.array(obs),\n 'action': np.array(acts),\n 'entropy': entropy,\n 'info': info,\n 'machine':np.array(machines)\n }","def run_episode(self):\n self.reset_episode()\n obs = self.env.reset()\n while True:\n action = self.Policy[self.env.stateDict[obs]]\n new_obs, reward, done, _ = self.env.step(action)\n if self.mode=='debug':\n print(\"PrevObs:{}, Action:{}, Obs:{}, Reward:{}, Done:{}\"\n .format(obs, action, new_obs,reward,done))\n self.totalReward += reward\n self.totalSteps += 1\n if done:\n break\n else:\n obs = new_obs\n return self.totalReward","def doEpisodes(self, number = 1):\n all_rewards = []\n for dummy in range(number):\n self.agent.newEpisode()\n rewards = []\n self.stepid = 0\n self.task.reset()\n while not self.task.isFinished():\n r = self._oneInteraction()\n rewards.append(r)\n all_rewards.append(rewards)\n return all_rewards","def collect_episode(env, policy, buffer, render_option):\n state = env.reset()\n done = False\n while not done:\n if render_option == 'collect':\n env.render()\n action = policy(state)\n next_state, reward, done, _ = env.step(action)\n if done:\n reward = -1.0\n buffer.record(state, reward, next_state, action, done)\n state = next_state","def scraping_episodes(self, serie_data, episodes_list):\n episodes_data = []\n for episode in episodes_list:\n # Se arma este dict para localizar los campos\n # en el json y que sea mas facil procesarlos mas adelante\n epi_details = episode[0]['body']['details']\n epi_dict = {\n 'ParentId': serie_data.id,\n 'ParentTitle': serie_data.clean_title,\n 'Id': episode[0]['id'],\n 'Title': epi_details['title'],\n 'Type': 'episode',\n 'JSON': {\n 'Synopsis': epi_details['description'],\n 'Metadata': epi_details['metadata'].replace('\\xa0', ''),\n 'Rating': epi_details['localizedRating']['value'],\n 'Image': epi_details,\n 'Groups': episode[1]['body']['groups'],\n 'SeasonAndNumber': episode[2]['body']['metadata'],\n 'isFree': episode[0]['body']['isFree']\n }\n }\n payload_epi = self.build_payload(epi_dict)\n # Si la serie es original sus episodios también\n payload_epi.is_original = serie_data.is_original\n episodes_data.append(payload_epi)\n payload_epi = payload_epi.payload_episode()\n Datamanager._checkDBandAppend(\n self, payload_epi, self.scraped_epi, self.payloads_epi,\n isEpi=True\n )\n return episodes_data","def explore(self, episode_count):\n # single agent, always use the `run_one_episode` api.\n # multi agent with `standalone` api_type, use the `run_one_episode` api.\n if self.env_info[\"api_type\"] == \"standalone\":\n # (use_explore, collect)\n _paras = [\n (True, False if _ag.alg.async_flag else True) for _ag in self.agents\n ]\n job_funcs = [agent.run_one_episode for agent in self.agents]\n for _epi_index in range(episode_count):\n _start2 = time()\n self.env.reset()\n for agent in self.agents:\n agent.reset()\n\n trajectory_list = self.bot.do_multi_job(job_funcs, _paras)\n for agent, trajectory in zip(self.agents, trajectory_list):\n if not agent.alg.async_flag:\n # self.trajectories.append(trajectory)\n self.send_explorer.send(trajectory)\n\n self._post_processes()\n self.ag_stats.explore_time_in_epi = time() - _start2\n\n if _epi_index == episode_count - 1:\n self.ag_stats.update_with_agent_stats(\n [agent.get_perf_stats() for agent in self.agents]\n )\n\n elif self.env_info[\"api_type\"] == \"unified\":\n for _ in range(episode_count):\n _start2 = time()\n trajectories = self._run_one_unified_episode(\n use_explore=True, collect=True)\n\n for _ag, trajectory in zip(self.agents, trajectories):\n if not _ag.alg.async_flag:\n # self.trajectories.append(trajectory)\n self.send_explorer.send(trajectory)\n\n self._post_processes()\n self.ag_stats.explore_time_in_epi = time() - _start2\n else:\n pass\n\n self.clear_trajectories()\n return self.ag_stats.get()","def generate_episode(env, policy, max_steps=500):\n episode = []\n curr_state = env.reset() # reset the environment and place the agent in the start square\n ############################\n # YOUR IMPLEMENTATION HERE #\n \n finished = False\n steps = 0\n \n while not finished and steps < max_steps: # Continue generating episode until finished or max_steps\n # while steps < max_steps:\n action, reward, new_state, finished = take_one_step(env, policy, curr_state) # take a new action in the current state, get new state\n episode.append((curr_state, action, reward))\n curr_state = new_state\n steps += 1\n ############################\n \n return episode","def on_episode_end(self, episode, logs):\n duration = timeit.default_timer() - self.episode_start[episode]\n episode_steps = len(self.observations[episode])\n\n # Format all metrics.\n metrics = np.array(self.metrics[episode])\n metrics_template = ''\n metrics_variables = []\n with warnings.catch_warnings():\n warnings.filterwarnings('error')\n for idx, name in enumerate(self.metrics_names):\n if idx > 0:\n metrics_template += ', '\n try:\n value = np.nanmean(metrics[:, idx])\n metrics_template += '{}: {:f}'\n except Warning:\n value = '--'\n metrics_template += '{}: {}'\n metrics_variables += [name, value]\n metrics_text = metrics_template.format(*metrics_variables)\n\n nb_step_digits = str(int(np.ceil(np.log10(self.params['nb_steps']))) + 1)\n # template = '{step: nb_step_digits}/{nb_steps}: episode: {episode}, duration: {duration:.3f}s, episode steps: {episode_steps}, steps per second: {sps:.0f}, episode reward: {episode_reward:.3f}, mean reward: {reward_mean:.3f} [{reward_min:.3f}, {reward_max:.3f}], mean action: {action_mean:.3f} [{action_min:.3f}, {action_max:.3f}], mean observation: {obs_mean:.3f} [{obs_min:.3f}, {obs_max:.3f}], {metrics}'\n template = '(( episode: {episode}, step: {steps}/{nb_steps}, episode_steps: {episode_steps} --- target_reached: {target_reached}, target_reached_in_steps: {target_reached_in_steps} --- episode_reward: {episode_reward:.3f}, mean_reward: {reward_mean:.3f} --- metrics: {metrics} ))'\n variables = {\n # 'step': self.step,\n 'nb_steps': self.params['nb_steps'],\n 'episode': episode + 1,\n # 'duration': duration,\n 'episode_steps': episode_steps,\n # 'sps': float(episode_steps) / duration,\n # 'episode_reward_sum': np.sum(self.rewards[episode]),\n 'reward_mean': np.mean(self.rewards[episode]),\n # 'reward_min': np.min(self.rewards[episode]),\n # 'reward_max': np.max(self.rewards[episode]),\n # 'action_mean': np.mean(self.actions[episode]),\n # 'action_min': np.min(self.actions[episode]),\n # 'action_max': np.max(self.actions[episode]),\n # 'obs_mean': np.mean(self.observations[episode]),\n # 'obs_min': np.min(self.observations[episode]),\n # 'obs_max': np.max(self.observations[episode]),\n 'steps': logs['steps'],\n 'target_reached': logs['target_reached'],\n 'target_reached_in_steps': logs['target_reached_in_steps'],\n 'episode_reward': logs['episode_reward'],\n 'metrics': metrics_text,\n }\n print(template.format(**variables))\n\n # Free up resources.\n del self.episode_start[episode]\n del self.observations[episode]\n del self.rewards[episode]\n del self.actions[episode]\n del self.metrics[episode]","def _flat_data_to_episodes(self, flat_data):\n data = []\n episode_start = 0\n for t in range(len(flat_data['observations'])):\n if flat_data['terminals'][t]:\n episode = {k: v[episode_start:t + 1] for k, v in flat_data.items()}\n data.append(episode)\n episode_start = t + 1\n return data","def train(n_episodes=1000, max_n_steps=300, eps_start=1.0, eps_end=0.01, eps_decay=0.995, strCheckpointFile='checkpoint.pth'):\n\n global env\n scores = [] # list containing scores from each episode\n scores_window = deque(maxlen=100) # last 100 scores\n eps = eps_start # initialize epsilon\n num_saves = 0\n for i_episode in range(1, n_episodes + 1):\n env_info = env.reset(train_mode=True)[brain_name] # reset the environment\n state = env_info.vector_observations[0] # get the current state\n score = 0 # initialize the score\n last_t = max_n_steps\n for t in range(max_n_steps):\n action = agent.act(state, eps) # agent returns an epsilon-greedy action based on state\n env_info = env.step(action)[brain_name] # send the action to the environment\n next_state = env_info.vector_observations[0] # get the next state\n reward = env_info.rewards[0] # get the reward\n done = env_info.local_done[0] # see if episode has finished\n agent.step(state, action, reward, next_state, done) # records experience and learns (depending on settings)\n state = next_state\n score += reward\n if done:\n last_t = t + 1\n break\n scores_window.append(score) # save most recent score\n scores.append(score) # save most recent score\n eps = max(eps_end, eps_decay * eps) # decrease epsilon\n print('\\rEpisode {}\\tNum steps: {}\\tAverage Score: {:.2f}'.format(i_episode, last_t, np.mean(scores_window)))\n # if i_episode % 100 == 0:\n # print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n if np.mean(scores_window) >= 13: # win condition in course\n if num_saves == 0:\n print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode - 100, np.mean(scores_window)))\n print('\\nTraining will continue and the checkpoint will be overwritten every 100 episodes')\n print('\\nSaving a checkpoint now, you may interrupt code execution with eg Ctrl+C')\n torch.save(agent.qnetwork_local.state_dict(), strCheckpointFile)\n else:\n if i_episode % 100 == 0:\n print('\\nSaving another checkpoint now, you may interrupt code execution with eg Ctrl+C')\n torch.save(agent.qnetwork_local.state_dict(), strCheckpointFile)\n num_saves += 1\n\n env.close()\n\n # plot the scores\n fig = plt.figure()\n ax = fig.add_subplot(111)\n plt.plot(np.arange(len(scores)), scores)\n plt.ylabel('Score')\n plt.xlabel('Episode #')\n # plt.show()\n plt.savefig('training_score_by_episode.png')\n return scores","def train_dqn(self, n_episodes=2000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n self.scores = [] # list containing scores from each episode\n scores_window = deque(maxlen=100) # last 100 scores\n eps = eps_start # initialize epsilon\n for i_episode in range(1, n_episodes+1):\n env_info = self.env.reset(train_mode=True)[self.brain_name] # reset the environment\n state = env_info.vector_observations[0] # get the current state\n score = 0 # initialize the score\n for t in range(max_t):\n action = self.agent.act(state, eps)\n env_info = self.env.step(action)[self.brain_name] # send the action to the environment\n next_state = env_info.vector_observations[0] # get the next state\n reward = env_info.rewards[0] # get the reward\n done = env_info.local_done[0] # see if episode has finished\n self.agent.step(state, action, reward, next_state, done)\n state = next_state\n score += reward\n if done:\n break \n scores_window.append(score) # save most recent score\n self.scores.append(score) # save most recent score\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n if i_episode % 100 == 0:\n print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n # we use 15.0 just to be sure\n if np.mean(scores_window)>=self.threshold:\n print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\n break\n return self.scores","def get_episode_list(self):\n if self.episodes is not None:\n return self.episodes\n\n self.episodes = []\n\n # Now before we return pre-emptively fetch the episode list.\n # XXX We _could_ put this in a 'get_episode_list' method that does the\n # fetching then.. but for now we are just going to have it done\n # here.\n #\n if len(self.episode_guide_urls) == 0:\n return self.episodes\n\n for url in self.episode_guide_urls:\n url_data = url.get()\n\n # Now we run the GetEpisodeList rules on this data that\n # we just retrieved.\n #\n self.scraper.parser.set_buffer(1, url_data)\n self.scraper.parser.set_buffer(2, url.url)\n\n # This gets us a XML string with the list of episodes in it.\n # parse this in to a dom and then go through each <episode>\n # element creating an Episode object to append to our episode\n # list\n ep_list_result = self.scraper.parser.parse(FN_GET_EPISODE_LIST,\n self.scraper.settings)\n dom = parseString(ep_list_result)\n eps = dom.firstChild\n ep = first_child(eps, \"episode\")\n while ep:\n self.episodes.append(Episode(ep, self, self.scraper))\n ep = next_sibling(ep, \"episode\")\n dom.unlink()\n dom = None\n \n return self.episodes","def stopEpisode(self):\n if self.episodesSoFar < self.numTraining:\n self.accumTrainRewards += self.episodeRewards\n else:\n self.accumTestRewards += self.episodeRewards\n self.episodesSoFar += 1\n if self.episodesSoFar >= self.numTraining:\n # Take off the training wheels\n self.epsilon = 0.0 # no exploration\n self.alpha = 0.0 # no learning","def train(self):\n tic = time.time()\n means = []\n stds = []\n steps = 0\n scores_window = deque(maxlen=100)\n for e in range(1,self.episodes):\n\n self.noise.step()\n episode_scores = []\n obs = self.env.reset()\n for t in range(self.tmax):\n actions = self.act(obs)\n next_obs,rewards,dones = self.env.step(actions)\n\n # Store experience\n if np.max(rewards) > 0:\n print('hit the ball over the net',rewards)\n self.R.add(obs.reshape(1,48),obs,actions,rewards,next_obs.reshape(1,48),next_obs,dones)\n obs = next_obs\n # Score tracking\n episode_scores.append(np.max(rewards))\n \n # Learn\n if len(self.R) > self.min_buffer_size:\n for _ in range(self.SGD_epoch):\n # Update each agent\n for i in range(self.num_agents):\n self.learn(i)\n # update target networks\n self.update_targets_all()\n \n steps += int(t)\n means.append(np.mean(episode_scores))\n stds.append(np.std(episode_scores))\n scores_window.append(np.sum(episode_scores))\n if e % 4 == 0:\n toc = time.time()\n r_mean = np.mean(scores_window)\n r_max = max(scores_window)\n r_min = min(scores_window)\n r_std = np.std(scores_window)\n plot(self.name,means,stds)\n print(\"\\rEpisode: {} out of {}, Steps {}, Rewards: mean {:.2f}, min {:.2f}, max {:.2f}, std {:.2f}, Elapsed {:.2f}\".format(e,self.episodes,steps,r_mean,r_min,r_max,r_std,(toc-tic)/60))\n if np.mean(scores_window) > self.winning_condition:\n print('Env solved!')\n # save scores\n pickle.dump([means,stds], open(str(self.name)+'_scores.p', 'wb'))\n # save policy\n self.save_weights(self.critic_path,self.actor_path)\n break","def run_episode(self):\n # Reset environment\n self.agent.env.reset()\n done = False\n step_count = 0\n total_reward = 0\n\n while not done:\n reward, done = self.agent.explore()\n step_count += 1\n if step_count % 100 == 0:\n print('step count {}'.format(step_count))\n total_reward += self.agent.params['gamma']**step_count * reward\n return step_count, total_reward","def terminal_test(self):\n\n for self.cur_ep in tqdm.tqdm(range(1, self.episodes + 1), ascii=True, unit='episodes'):\n\n # Nombre de passages dans la boucle principale\n step = 1\n\n cur_state = self.env.reset()\n\n done = False\n\n while not done:\n\n # Choix au hasard entre :\n if np.random.random() > self.epsilon:\n # Action à partir de la q-table\n action = np.argmax(self.agent.get_q_values(np.array(cur_state)))\n\n else:\n # Action random\n action = np.random.randint(0, self.env.ACTION_SPACE_SIZE)\n\n # On effectue une action avec le serpent\n new_state, reward, done = self.env.step(action)\n\n # Ajout d'un exemple dans la mémoire\n self.agent.update_training_set((cur_state, action, reward, new_state, done))\n\n # Entrainement éventuel\n self.agent.train()\n\n cur_state = new_state\n step += 1\n\n if self.epsilon > self.MIN_EPSILON:\n self.epsilon *= self.EPSILON_DECAY\n self.epsilon = max(self.MIN_EPSILON, self.epsilon)\n\n if self.save_model:\n self.agent.save_model(self.model_file_name)","def stopEpisode(self):\n if self.episodesSoFar < self.numTraining:\n self.accumTrainRewards += self.episodeRewards\n else:\n self.accumTestRewards += self.episodeRewards\n self.episodesSoFar += 1\n if self.episodesSoFar >= self.numTraining:\n # Take off the training wheels\n self.epsilon = 1.0 # no exploration\n self.lr = 0.0 # no learning","def train_multiple_eps(self, env, no_episodes=200, horizon=1000, lr=0.1):\n\n\t\tr_vec = []\n\t\tep_len_vec = []\n\t\tfor i in range(no_episodes):\n\n\t\t\t# Run the agent for one episode and get a vector of rewards and a scalar for episode length\n\t\t\tr_ep, ep_len = self.train_one_eps(env, horizon=horizon, lr=lr)\n\n\t\t\t# Storing the information\n\t\t\tr_vec.append(r_ep)\n\t\t\tep_len_vec.append(ep_len)\n\n\t\treturn r_vec, ep_len_vec","def test():\n env = gym.make('CartPole-v1')\n\n results = []\n for _ in range(100):\n results.append(episode(env, render=False, verbose=False))\n\n print(f'average={sum(results) / len(results)} '\n f'max={max(results)} '\n f'min={min(results)}')","def episode_terminated(self):\n # Increase the number of episodes\n self.episode_count += 1\n self.representation.episode_terminated()\n # Set eligibility Traces to zero if it is end of the episode\n if self.eligibility_trace is not None:\n self.eligibility_trace = np.zeros_like(self.eligibility_trace)","def save_episode_models(self, episode):\n s1 = './' + self.game_name + '/'\n s_pth = '{}.pth'.format(episode + 1)\n torch.save(self.actor.state_dict(), s1 + 'actor' + s_pth)\n torch.save(self.critic1.state_dict(), s1 + 'critic1_' + s_pth)\n torch.save(self.critic2.state_dict(), s1 + 'critic2_' + s_pth)\n torch.save(self.critic1_target.state_dict(), s1 + 'critic1_target' + s_pth)\n torch.save(self.critic2_target.state_dict(), s1 + 'critic2_target' + s_pth)\n\n torch.save(self.log_alpha, s1 + 'log_alpha' + s_pth)\n\n torch.save(self.actor_optimiser.state_dict(), s1 + 'actor_optimizer' + s_pth)\n torch.save(self.critic1_optimiser.state_dict(), s1 + 'critic1_optimizer' + s_pth)\n torch.save(self.critic2_optimiser.state_dict(), s1 + 'critic2_optimizer' + s_pth)\n torch.save(self.alpha_optimiser.state_dict(), s1 + 'alpha_optimizer' + s_pth)\n np.save(s1 + 'scores{}.npy'.format(episode + 1), self.scores)","def learn(self):\n\n for i in range(1, self.args.numIters + 1):\n print('------ ITER ' + str(i) + '------')\n iterationTrainExamples = deque([], maxlen=self.args.maxlenOfQueue)\n\n for eps in range(self.args.numEps):\n print('------ Self Play Episode ' + str(eps) + '------')\n self.mcts = TSPMCTS(self.args, self.game, self.nnet) # reset search tree\n iterationTrainExamples += self.executeEpisode()\n\n # save the iteration examples to the history\n self.trainExamplesHistory.append(iterationTrainExamples)\n\n if len(self.trainExamplesHistory) > self.args.numItersForTrainExamplesHistory:\n self.trainExamplesHistory.pop(0)\n\n # shuffle examples before training\n trainExamples = []\n for e in self.trainExamplesHistory:\n trainExamples.extend(e)\n\n # training new network\n if self.args.numEps > 0:\n self.nnet.train(trainExamples)\n nmcts = TSPMCTS(self.args, self.game, self.nnet)\n\n print('PLAYING GAMES')\n if self.args.arenaCompare:\n arena = SinglePlayerArena(lambda x: np.argmax(nmcts.getActionProb(x, temp=0)), self.game)\n wins, losses = arena.playSinglePlayerGames(self.args.arenaCompare)\n print('WINS/LOSSES: %d / %d' % (wins, losses))","def run_episode(self, mode=0, eps=0.):\n if mode==0:\n eps = 0.\n done = False\n score = 0 \n \n while not done:\n state = self.env_info.vector_observations[0] # get the current state\n action = self.agent.act(state, eps=eps) # get an action using epsilon greedy policy\n self.env_info = self.env.step(action)[self.brain_name] # send the action to the environment\n next_state = self.env_info.vector_observations[0] # get the next state\n reward = self.env_info.rewards[0] # get the reward\n done = self.env_info.local_done[0] # see if episode has finished\n \n if mode == 1:\n self.agent.step(state, action, reward, next_state, done)\n \n score += reward\n \n self.reset_env() # reset the environment\n \n return score","def run_episode(env, gamma = 1.0, render = False):\n actions = 4\n obs = env.reset()\n total_reward = 0\n step_idx = 0\n\n while True:\n if render:\n env.render()\n obs, reward, done , _ = env.step(random.randint(0, actions - 1))\n x1, x2, x3, x4, x5, x6, x7, x8 = obs\n x1s.append(x1)\n x2s.append(x2)\n x3s.append(x3)\n x4s.append(x4)\n x5s.append(x5)\n x6s.append(x6)\n x7s.append(x7)\n x8s.append(x8)\n total_reward += (gamma ** step_idx * reward)\n step_idx += 1\n if done:\n break\n return total_reward, step_idx","def n_episodes(self):\n raise NotImplementedError","def store_episode(self):\n episode_buffer = self._convert_episode_to_batch_major()\n episode_batch_size = len(episode_buffer['observation'])\n idx = self._get_storage_idx(episode_batch_size)\n\n for key in self._buffer:\n self._buffer[key][idx] = episode_buffer[key]\n self._n_transitions_stored = min(\n self._size_in_transitions, self._n_transitions_stored +\n self._time_horizon * episode_batch_size)","def episode_step(self):\n self.nsteps += 1","def execute_and_get_episodes(self, num_episodes, max_timesteps_per_episode=0, deterministic=False):\n pass","def train(self, num_episodes=10000):\n\n self.game.restart()\n\n self.exp_states = defaultdict(int)\n\n for i in tqdm(range(num_episodes)):\n\n self.game.deal_cards()\n\n possible_actions = self.game.get_actions()\n\n player_state = self.game.get_player_state()\n player_action = self.player.get_action(player_state,\n possible_actions,\n explore_exploit='explore')\n\n # Bookkeep visited states (?)\n player_state_str = np.array2string(player_state)\n self.exp_states[player_state_str] += 1\n\n opponent_state = self.game.get_opponent_state()\n opponent_action = self.opponent.get_action(opponent_state,\n possible_actions)\n\n self.game.set_player_action(player_action)\\\n .set_opponent_action(opponent_action)\n\n player_score, opponent_score = self.game.get_scores()\n\n reward = self._get_reward(player_score, opponent_score)\n self.player.learn(player_state,\n player_action,\n reward)\n self.player.learn(opponent_state,\n opponent_action,\n -reward)\n \n print(\"Training done!\")","def collect_selfplay_data(self):\n winner, play_data = self.game.start_self_play(self.mcts_player,\n temp=self.temp)\n play_data = list(play_data)[:]\n episode_len = len(play_data)\n # augment the data\n play_data = self.get_equi_data(play_data)\n self.data_buffer.extend(play_data)\n return episode_len","def Worker(episode):\n episode_start_time = time.monotonic()\n\n stop = 0\n near_boundaries = 0\n failed = 0\n\n cdf_t = -1.0 * np.ones(LEN_CDF_T)\n cdf_h = -1.0 * np.ones(LEN_CDF_H)\n bin_t = 0\n bin_h = 0\n cdf_t[bin_t] = 0.0\n cdf_h[bin_h] = 0.0\n\n myenv, mypol = init_envs()\n check_envs(myenv, mypol)\n\n t = 0 # time step\n cumulative_hits = 0 # cumulative number of hits (int)\n T_mean = 0\n p_not_found_yet = 1\n\n while True:\n\n # choice of action\n action = mypol.choose_action()\n\n # step in myenv\n hit, p_end, done = myenv.step(action, quiet=(mypol.policy_index == -1))\n near_boundaries = max(near_boundaries, myenv.agent_near_boundaries)\n\n t += 1\n T_mean += p_not_found_yet\n\n p_found = 1.0 - p_not_found_yet * (1.0 - p_end)\n\n bin_to = bin_t\n bin_t = int((t - BIN_START_T) // BIN_SIZE_T)\n cdf_t[bin_to:bin_t] = cdf_t[bin_to]\n cdf_t[bin_t] = p_found\n\n bin_ho = bin_h\n bin_h = int((cumulative_hits - BIN_START_H) // BIN_SIZE_H)\n cdf_h[bin_ho:bin_h] = cdf_h[bin_ho]\n cdf_h[bin_h] = p_found\n\n p_not_found_yet *= 1 - p_end\n cumulative_hits += hit\n\n if p_not_found_yet < STOP_p or p_end > 1 - EPSILON or done:\n stop = 1\n elif t > STOP_t - 1:\n stop = 2\n failed = 1\n elif myenv.agent_stuck:\n stop = 3\n failed = 1\n\n if stop:\n if episode % 100 == 0 and sys.stdout.isatty() and not WITH_MPI:\n txt = \"episode: %7d [hit(t0) = %d] || <nsteps>: %7.2f || total nb of steps: %d\" \\\n % (episode, myenv.initial_hit, T_mean, t)\n if stop == 1:\n print(txt)\n elif stop == 2:\n print(txt + \" || max iter reached! (prob not found yet = %7.2e)\" % p_not_found_yet)\n elif stop == 3:\n print(txt + \" || agent stuck! (prob not found yet = %7.2e)\" % p_not_found_yet)\n\n sys.stdout.flush()\n break\n\n # fill in remaining bins\n cdf_t[bin_t + 1:LEN_CDF_T] = cdf_t[bin_t]\n cdf_h[bin_h + 1:LEN_CDF_H] = cdf_h[bin_h]\n\n if np.any(cdf_t < 0) or np.any(cdf_h < 0):\n raise Exception(\"Missing values in the cdf, check implementation\")\n\n # monitoring\n episode_elapsed_time = time.monotonic() - episode_start_time\n monitoring_episode_tmp_file = os.path.join(DIR_TMP, str(\"monitoring_episode_\" + str(episode) + \".txt\"))\n with open(monitoring_episode_tmp_file, \"a\") as mfile:\n mfile.write(\"%9d\\t%8d\\t%9d\\t%13d\\t%11.2e\\t%15.4e\\t%21.4e\\n\" % (\n episode, myenv.initial_hit, stop, near_boundaries, p_not_found_yet, T_mean, episode_elapsed_time))\n\n return cdf_t, cdf_h, T_mean, failed","def _sample_episode(self):\n\n Knovel = random.sample(self.labelIds, self.nKnovel)\n #print(Knovel)\n #exit(0)\n nKnovel = len(Knovel)\n assert((self.nTestNovel % nKnovel) == 0)\n nEvalExamplesPerClass = int(self.nTestNovel / nKnovel)\n #print(nEvalExamplesPerClass)\n #exit(0)\n Tnovel = []\n Exemplars = []\n for Knovel_idx in range(len(Knovel)):\n ids = (nEvalExamplesPerClass + self.nExemplars)\n img_ids = random.sample(self.labels2inds[Knovel[Knovel_idx]], ids) \n\n imgs_tnovel = img_ids[:nEvalExamplesPerClass]\n imgs_emeplars = img_ids[nEvalExamplesPerClass:]\n #print(imgs_tnovel)\n #exit(0)\n Tnovel += [(img_id, Knovel_idx) for img_id in imgs_tnovel]\n Exemplars += [(img_id, Knovel_idx) for img_id in imgs_emeplars]\n assert(len(Tnovel) == self.nTestNovel)\n assert(len(Exemplars) == nKnovel * self.nExemplars)\n random.shuffle(Exemplars)\n random.shuffle(Tnovel)\n\n return Tnovel, Exemplars","def finish_episode(tribes, learners, optimizers, gamma, cuda): \n \n num_learners = len(learners)\n total_norms = [0 for i in range(num_learners)]\n policy_losses = [[] for i in range(num_learners)]\n losses = [[] for i in range(num_learners)]\n T_reward = []\n\n \n for i in range(num_learners):\n\n R = 0\n saved_actions = learners[i].saved_actions\n \n for t in tribes:\n if t.name is learners[i].tribe:\n \n # Based on team culture, calculate the team reward for the agent \n culture = t.culture['name']\n \n if culture is 'cooperative':\n T_reward = t.tribal_awards()\n elif culture is 'individualist':\n T_reward = t.tribal_awards()\n elif culture is 'no_fragging':\n T_reward = t.tribal_awards(US_hits = learners[i].US_hits)\n elif culture is 'pacifist':\n T_reward = t.tribal_awards(tag_hist = learners[i].tag_hist)\n elif culture is 'pacifist_exile':\n T_reward = t.tribal_awards(tag_hist = learners[i].tag_hist, \\\n in_banned_hist=learners[i].in_banned_hist)\n elif culture is 'pacifist_follower':\n T_reward = t.tribal_awards(tag_hist = learners[i].tag_hist, \\\n in_target_hist=learners[i].in_target_hist)\n elif culture is 'warlike':\n T_reward = t.tribal_awards(US_hits = learners[i].US_hits,THEM_hits = learners[i].THEM_hits)\n else:\n T_reward = t.tribal_awards()\n \n # For debug only\n # print('Agent{} receives tribal award from Tribe{}'.format(i,t.name))\n # print (T_reward)\n # print (learners[i].rewards)\n \n # Do not implement actor-critic for now\n # value_losses = []\n \n rewards = deque()\n\n for r,T in zip(learners[i].rewards[::-1],T_reward[::-1]):\n # The agent is incentivized to cooperate by an award of 30% of what the tribe takes\n # in by all its members\n R = r + T + gamma * R\n rewards.appendleft(R)\n \n rewards = list(rewards)\n rewards = torch.Tensor(rewards)\n if cuda:\n rewards = rewards.cuda()\n\n # z-score rewards\n rewards = (rewards - rewards.mean()) / (1.1e-7+rewards.std())\n \n #Debug \n #print (rewards) \n \n \"\"\"\n Do not implement actor-critic for now!!!\n for (log_prob, state_value), r in zip(saved_actions, rewards):\n reward = r - state_value.data[0]\n policy_losses.append(-log_prob * Variable(reward))\n r = torch.Tensor([r])\n if cuda:\n r = r.cuda()\n value_losses.append(torch.nn.functional.smooth_l1_loss(state_value,\n Variable(r)))\n\n optimizer.zero_grad()\n loss = torch.stack(policy_losses).sum() + torch.stack(value_losses).sum()\n loss.backward() \n \n \n \"\"\"\n for log_prob, r in zip(saved_actions, rewards):\n r = torch.Tensor([r])\n if cuda:\n r = r.cuda()\n policy_losses[i].append(-log_prob * Variable(r))\n\n optimizers[i].zero_grad()\n losses[i] = torch.stack(policy_losses[i]).sum()\n losses[i].backward()\n \n # Gradient Clipping Update: prevent exploding gradient\n total_norms[i] = torch.nn.utils.clip_grad_norm_(learners[i].parameters(), 8000)\n \n optimizers[i].step()\n learners[i].clear_history() # clear an agent's history at the end of episode\n\n\n return total_norms","def train(env, agent, n_episodes:int=1000, max_t:int=1000, eps_start:float=1.0, eps_end:float=0.01, eps_decay:float=0.995, score_threshold:float=13)->list:\n scores = []\n scores_window:Deque[float] = deque(maxlen=100)\n eps = eps_start\n best_score = float(\"-inf\")\n writer = tensorboard.SummaryWriter(f\"runs/{int(time())}\")\n for i_episode in range(1, n_episodes+1):\n state = env.reset()\n score = 0\n writer.add_scalar(\"train/epsilon\", eps, i_episode)\n \n start = time()\n for t in range(max_t):\n action = agent.act(state, eps)\n next_state, reward, done, _ = env.step(action)\n # writer.add_scalar(\"reward\", reward, (i_episode - 1) * max_t + t)\n agent.step(state, action, reward, next_state, done)\n state = next_state\n score += reward\n if done:\n break\n\n time_for_episode = time() - start\n writer.add_scalar(\"train/time\", time_for_episode, i_episode)\n scores_window.append(score)\n scores.append(score)\n\n eps = max(eps_end, eps_decay*eps)\n window_score = np.mean(scores_window)\n\n writer.add_scalar(\"train/reward\", score, i_episode) \n writer.add_scalar(\"train/window\", window_score, i_episode)\n writer.add_scalar(\"train/memory_size\", len(agent.memory), i_episode)\n\n probs = getattr(agent.memory, 'probs', None)\n if probs is not None:\n writer.add_histogram(\"train/memory_probs\", probs, i_episode)\n\n beta = getattr(agent.memory, 'beta', None)\n if beta is not None:\n writer.add_scalar(\"train/memory_beta\", beta, i_episode)\n agent.memory.beta = min(1., agent.memory.beta + agent.memory.beta_incremental)\n \n print(f'\\rEpisode {i_episode}\\tAverage Score: {window_score:.2f}\\tTime: {time_for_episode:.2f}', end=\"\")\n \n if i_episode % 100 == 0:\n print(f'\\rEpisode {i_episode}\\tAverage Score: {window_score:.2f}')\n\n if window_score >= score_threshold and best_score < score_threshold:\n print(f'\\nEnvironment solved in {i_episode:d} episodes!\\tAverage Score: {window_score:.2f}')\n\n if window_score > best_score and window_score >= score_threshold:\n best_score = window_score\n torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pt')\n\n memory_dump = getattr(agent.memory, 'memory', None) \n if memory_dump is not None: \n torch.save(memory_dump, \"memory.pt\")\n\n print(f\"Best average score: {best_score}\")\n writer.close()\n return scores","def OnEpisodeOver(self):\n pass","def run_episode(env, agents, eval=False, render=False, generate_val_data=False, greedy_eval=True, steps=25, store_data=False, trainer=None):\n obs_n = env.reset()\n reward_tot = [0.0 for i in range(len(agents))]\n reward_n = [0.0 for i in range(len(agents))]\n done_n = [False for i in range(len(agents))]\n\n if store_data:\n observations = []\n rewards = []\n rewards_details = {\"rewards_target\": [], \"rewards_collision\": []}\n actions = []\n\n # Start env\n for i in range(steps):\n\n # query for action from each agent's policy\n act_n = []\n if store_data or True:\n observations.append(obs_n)\n actions.append([])\n rewards.append(reward_n)\n # Take actions\n action_list = []\n for j, agent in enumerate(agents):\n action_unscaled = agent.step(obs_n[j], reward_n[j], done=done_n[0], eval=eval,\n generate_val_data=generate_val_data, greedy_eval=greedy_eval)\n action_list.append(action_unscaled)\n if store_data:\n actions[-1].append(action_unscaled)\n action = scale_action(env, j, action_unscaled)\n act_n.append(action)\n if trainer is not None and not eval:\n trainer.step(obs_n, reward_n, action_list, done=done_n)\n # step environment\n obs_n, reward_n, done_n, info_n = env.step(act_n)\n\n for j, r in enumerate(reward_n):\n reward_tot[j] += r\n if done_n[0]:\n for j, agent in enumerate(agents):\n action = scale_action(env, j, agent.step(obs_n[j], reward_n[j], done=done_n[0], eval=eval,\n generate_val_data=generate_val_data, greedy_eval=greedy_eval))\n act_n.append(action)\n agent.reset()\n break\n\n # render all agent views\n if render:\n env.render()\n for j, agent in enumerate(agents):\n agent.reset()\n if trainer is not None:\n trainer.reset()\n if not store_data:\n return reward_tot, i + 1\n else:\n extra_data = {\"observations\": observations, \"actions\": actions, \"rewards\": rewards, \"rewards_details\": rewards_details}\n return reward_tot, i + 1, extra_data","def self_play(self, n_episodes): \n eps = self.eps(self.agent.learning_iters)\n experiences = self_play_episodes(self.mdp, self.agent, n_episodes, eps) \n for state, action, reward, next_state, done in experiences:\n self.agent.replay_buffer.push(state, action, reward, next_state, done)","def generate_episode(env, policy, max_steps):\n episodes = []\n state = env.reset()\n for t in range(max_steps):\n action = policy(state)\n new_state, reward, done, _ = env.step(action)\n\n if done is True:\n episodes.append((state, action, 1))\n break\n episodes.append((state, action, reward))\n state = new_state\n return np.array(episodes, np.object)","def _generator(self):\n # Initial setup\n ac = self._env.action_space.sample() # not used, just so we have the datatype\n self.new = True # marks if we're on first timestep of an episode\n self.ob = self._convert_state(self._env.reset()) \n T = self._timesteps\n\n cur_ep_ret = 0 # return in current episode\n cur_ep_len = 0 # len of current episode\n ep_rets = [] # returns of completed episodes in this segment\n ep_lens = [] # lengths of ...\n\n # Initialize history arrays\n #obs = np.array([None for _ in range(T)])\n obs = nd.empty((T,) + self._env.observation_space.shape)\n rews = np.zeros(T, 'float32')\n vpreds = np.zeros(T, 'float32')\n news = np.zeros(T, 'int32')\n acs = np.array([ac for _ in range(T)])\n prevacs = acs.copy()\n\n t = 0\n while True:\n ob = self.ob # Use `self.` since `_evaluate` may have reset the env\n new = self.new\n prevac = ac\n ac, vpred = self._act(ob)\n # NOTE(openAI) Slight weirdness here because we need value function at time T\n # before returning segment [0, T-1] so we get the correct terminal value\n if t > 0 and t % T == 0:\n seg = {\"ob\": obs, \"rew\": rews, \"vpred\": vpreds, \"new\": news,\n \"ac\": acs, \"nextvpred\": vpred * (1 - new),\n \"ep_rets\": np.array(copy.deepcopy(ep_rets)),\n \"ep_lens\": np.array(copy.deepcopy(ep_lens))}\n self._add_vtarg_and_adv(seg, self._gamma, self._lambda)\n yield seg\n # NOTE: Do a deepcopy if the values formerly in these arrays are used later.\n ep_rets = []\n ep_lens = []\n i = t % T\n\n obs[i] = ob[0]\n vpreds[i] = vpred\n news[i] = new\n acs[i] = ac\n prevacs[i] = prevac\n\n ob, rew, new, _ = self._env.step(ac)\n ob = self._convert_state(ob)\n rews[i] = rew\n\n cur_ep_ret += rew\n cur_ep_len += 1\n if new:\n ep_rets.append(cur_ep_ret)\n ep_lens.append(cur_ep_len)\n cur_ep_ret = 0\n cur_ep_len = 0\n ob = self._convert_state(self._env.reset())\n self.new = new\n self.ob = ob\n t += 1","def add(self, episode, last_stuff=None):\n color, depth, action, info = [], [], [], []\n for obs, act, i in episode:\n color.append(obs['color'])\n depth.append(obs['depth'])\n action.append(act)\n info.append(i)\n\n color = np.uint8(color)\n depth = np.float32(depth)\n\n def dump(data, field):\n field_path = os.path.join(self.path, field)\n if not os.path.exists(field_path):\n os.makedirs(field_path)\n fname = f'{self.num_episodes:06d}-{len(episode)}.pkl'\n pickle.dump(data, open(os.path.join(field_path, fname), 'wb'))\n\n dump(color, 'color')\n dump(depth, 'depth')\n dump(action, 'action')\n dump(info, 'info')\n\n # Handle last stuff.\n if last_stuff is not None:\n last_color = np.uint8(last_stuff[0]['color'])\n last_depth = np.float32(last_stuff[0]['depth'])\n dump(last_color, 'last_color')\n dump(last_depth, 'last_depth')\n dump(last_stuff[1], 'last_info')\n else:\n print('Warning! last_stuff=None. We may require this later.')\n\n self.episode_id += [self.num_episodes] * len(episode)","def train(Game, agent, episodes=1000):\n a = agent\n # eps_start = a.epsilon\n # eps_end = a.epsilon_min\n # eps_dec = np.exp(1/episodes * np.log(eps_end/eps_start))\n # a.epsilon_decrement = eps_dec\n times_taken = np.zeros(episodes)\n print(\"Training starting\")\n for n in range(episodes):\n start_time = time.time()\n g = Game()\n print(\"EPISODE\", n+1)\n while not g.success:\n state = 1.0*g.get_state()\n action = a.action(state)\n reward = g.play(action)\n # print(g.success)\n # print(\"reward: \", reward)\n # print(state)\n # print(action)\n # print(g.get_state())\n a.train(state, action, reward, g.get_state(), g.success)\n end_time = time.time()\n times_taken[n] = end_time - start_time\n print(\"Training complete ({} episodes)\".format(episodes))\n return times_taken","def run_episode(env, agent, deterministic, skip_frames=0, do_training=True, rendering=False,\n max_timesteps=1000, history_length=0):\n\n stats = EpisodeStats()\n\n # Save history\n image_hist = []\n\n step = 0\n state = env.reset()\n\n # fix bug of corrupted states without rendering in gym environment\n env.viewer.window.dispatch_events()\n\n # append image history to first state\n state = state_preprocessing(state)\n image_hist.extend([state] * history_length)\n state = np.array(image_hist)#.reshape(96, 96, history_length)\n\n while True:\n\n # TODO: get action_id from agent\n # Hint: adapt the probabilities of the 5 actions for random sampling so that the agent explores properly. \n # action_id = agent.act(...)\n # action = your_id_to_action_method(...)\n action_id = agent.act(state, deterministic)\n action = id_to_action(action_id)\n\n # Hint: frame skipping might help you to get better results.\n reward = 0\n for _ in range(skip_frames + 1):\n next_state, r, terminal, info = env.step(action)\n reward += r\n\n if rendering:\n env.render()\n\n if terminal:\n break\n\n next_state = state_preprocessing(next_state)\n image_hist.append(next_state)\n image_hist.pop(0)\n next_state = np.array(image_hist)#.reshape(96, 96, history_length)\n\n if do_training:\n agent.train(state, action_id, next_state, reward, terminal)\n\n stats.step(reward, action_id)\n\n state = next_state\n\n if terminal or (step * (skip_frames + 1)) > max_timesteps:\n break\n\n step += 1\n\n return stats","def iterate(agents, E, t, episode_nr):\n global batch_size\n # print('I am inside one time step!')\n terminal_list = []\n for agent in agents:\n S = State(E, [agent.m, agent.n])\n if not agent.carry:\n\n S_new, action_number, r, terminal = agent.move_agent(S) # Moves agent\n\n agent.steps += 1\n agent.reward += r\n\n e = (S, action_number, r, S_new, terminal)\n agent.memory.append(e)\n\n E = S_new.grid # Update environment\n\n if len(agent.memory) > batch_size:\n batch = sample_batch(agent.memory, batch_size)\n agent.train_network(batch, episode_nr)\n\n terminal_list.append(terminal)\n\n if t % 50 == 0: # Choose time interval for updating target network weights\n agent.update_target_network()\n\n # print(E) # Show grid\n # print()\n\n # if episode_nr > 5:\n # show_grid(E, episode_nr)\n\n # show_grid(E, episode_nr)\n\n terminal = np.all(terminal_list) # True if all agents have reached destination\n env_list.append(E)\n\n return E, terminal","def get_aggregate(self, episode_queryset):\n pass"],"string":"[\n \"def add(self, episodes: Union[List[\\\"_Episode\\\"], \\\"_Episode\\\"]):\\n if isinstance(episodes, _Episode):\\n episodes = [episodes]\\n\\n for eps in episodes:\\n # Make sure we don't change what's coming in from the user.\\n # TODO (sven): It'd probably be better to make sure in the EnvRunner to not\\n # hold on to episodes (for metrics purposes only) that we are returning\\n # back to the user from `EnvRunner.sample()`. Then we wouldn't have to\\n # do any copying. Instead, either compile the metrics right away on the\\n # EnvRunner OR compile metrics entirely on the Algorithm side (this is\\n # actually preferred).\\n eps = copy.deepcopy(eps)\\n\\n self._num_timesteps += len(eps)\\n self._num_timesteps_added += len(eps)\\n\\n # Ongoing episode, concat to existing record.\\n if eps.id_ in self.episode_id_to_index:\\n eps_idx = self.episode_id_to_index[eps.id_]\\n existing_eps = self.episodes[eps_idx - self._num_episodes_evicted]\\n old_len = len(existing_eps)\\n self._indices.extend([(eps_idx, old_len + i) for i in range(len(eps))])\\n existing_eps.concat_episode(eps)\\n # New episode. Add to end of our episodes deque.\\n else:\\n self.episodes.append(eps)\\n eps_idx = len(self.episodes) - 1 + self._num_episodes_evicted\\n self.episode_id_to_index[eps.id_] = eps_idx\\n self._indices.extend([(eps_idx, i) for i in range(len(eps))])\\n\\n # Eject old records from front of deque (only if we have more than 1 episode\\n # in the buffer).\\n while self._num_timesteps > self.capacity and self.get_num_episodes() > 1:\\n # Eject oldest episode.\\n evicted_eps = self.episodes.popleft()\\n evicted_eps_len = len(evicted_eps)\\n # Correct our size.\\n self._num_timesteps -= evicted_eps_len\\n\\n # Erase episode from all our indices:\\n # 1) Main episode index.\\n evicted_idx = self.episode_id_to_index[evicted_eps.id_]\\n del self.episode_id_to_index[evicted_eps.id_]\\n # 2) All timestep indices that this episode owned.\\n new_indices = [] # New indices that will replace self._indices.\\n idx_cursor = 0\\n # Loop through all (eps_idx, ts_in_eps_idx)-tuples.\\n for i, idx_tuple in enumerate(self._indices):\\n # This tuple is part of the evicted episode -> Add everything\\n # up until here to `new_indices` (excluding this very index, b/c\\n # it's already part of the evicted episode).\\n if idx_cursor is not None and idx_tuple[0] == evicted_idx:\\n new_indices.extend(self._indices[idx_cursor:i])\\n # Set to None to indicate we are in the eviction zone.\\n idx_cursor = None\\n # We are/have been in the eviction zone (i pointing/pointed to the\\n # evicted episode) ..\\n elif idx_cursor is None:\\n # ... but are now not anymore (i is now an index into a\\n # non-evicted episode) -> Set cursor to valid int again.\\n if idx_tuple[0] != evicted_idx:\\n idx_cursor = i\\n # But early-out if evicted episode was only 1 single\\n # timestep long.\\n if evicted_eps_len == 1:\\n break\\n # Early-out: We reached the end of the to-be-evicted episode.\\n # We can stop searching further here (all following tuples\\n # will NOT be in the evicted episode).\\n elif idx_tuple[1] == evicted_eps_len - 1:\\n assert self._indices[i + 1][0] != idx_tuple[0]\\n idx_cursor = i + 1\\n break\\n\\n # Jump over (splice-out) the evicted episode if we are still in the\\n # eviction zone.\\n if idx_cursor is not None:\\n new_indices.extend(self._indices[idx_cursor:])\\n\\n # Reset our `self._indices` to the newly compiled list.\\n self._indices = new_indices\\n\\n # Increase episode evicted counter.\\n self._num_episodes_evicted += 1\",\n \"def _store_episode(self):\\n # For each transition in the last episode,\\n # create a set of artificial transitions\\n for transition_idx, transition in enumerate(self.episode_transitions):\\n\\n obs_t, action, reward, obs_tp1, done, info = transition\\n\\n # Add to the replay buffer\\n self.replay_buffer.add(obs_t, action, reward, obs_tp1, done)\\n\\n # We cannot sample a goal from the future in the last step of an episode\\n if (transition_idx == len(self.episode_transitions) - 1 and\\n self.goal_selection_strategy == GoalSelectionStrategy.FUTURE):\\n break\\n\\n # Sampled n goals per transition, where n is `n_sampled_goal`\\n # this is called k in the paper\\n sampled_goals = self._sample_achieved_goals(self.episode_transitions, transition_idx)\\n # For each sampled goals, store a new transition\\n for goal in sampled_goals:\\n # Copy transition to avoid modifying the original one\\n obs, action, reward, next_obs, done, info = copy.deepcopy(transition)\\n\\n # Convert concatenated obs to dict, so we can update the goals\\n obs_dict, next_obs_dict = map(self.env.convert_obs_to_dict, (obs, next_obs))\\n\\n # Update the desired goal in the transition\\n obs_dict['desired_goal'] = goal\\n next_obs_dict['desired_goal'] = goal\\n\\n # Update the reward according to the new desired goal\\n reward = self.env.compute_reward(next_obs_dict['achieved_goal'], goal, info)\\n # Can we use achieved_goal == desired_goal?\\n done = False\\n\\n # Transform back to ndarrays\\n obs, next_obs = map(self.env.convert_dict_to_obs, (obs_dict, next_obs_dict))\\n\\n # Add artificial transition to the replay buffer\\n self.replay_buffer.add(obs, action, reward, next_obs, done)\",\n \"def episodes(self):\\n episodes = []\\n for series in self.series:\\n episodes.extend(series.episodes)\\n return episodes\",\n \"def on_episode_begin(self, episode, logs):\\n self.episode_start[episode] = timeit.default_timer()\\n self.observations[episode] = []\\n self.rewards[episode] = []\\n self.actions[episode] = []\\n self.metrics[episode] = []\",\n \"def on_episode_begin(self, episode, logs):\\n self.episode_start[episode] = timeit.default_timer()\\n self.observations[episode] = []\\n self.rewards[episode] = []\\n self.actions[episode] = []\\n self.metrics[episode] = []\",\n \"def episodes(self, num_episodes, num_steps_per_episode):\\n for ep in range(num_episodes):\\n self.start_episode()\\n for step in range(num_steps_per_episode):\\n next_sensation,reward = self.env(self.next_action)\\n self.collect_data(self.last_sensation, self.next_action, reward, next_sensation)\\n self.next_action = self.agent(next_sensation,reward)\\n self.last_sensation = next_sensation\\n if self.last_sensation == TERMINAL_STATE:\\n break\",\n \"def executeEpisode(self):\\n trainExamples = []\\n board = self.game.getInitBoard()\\n self.curPlayer = 1\\n episodeStep = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = self.game.getCanonicalForm(board, self.curPlayer)\\n temp = int(episodeStep < self.args.tempThreshold)\\n\\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = self.game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, self.curPlayer, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n board, self.curPlayer = self.game.getNextState(board, self.curPlayer, action)\\n\\n r = self.game.getGameEnded(board, self.curPlayer)\\n\\n if r != 0:\\n return [(x[0], x[2], r * ((-1) ** (x[1] != self.curPlayer))) for x in trainExamples]\",\n \"def executeEpisode(self):\\n trainExamples = []\\n board = self.game.getInitBoard()\\n self.curPlayer = 1\\n episodeStep = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = self.game.getCanonicalForm(board, self.curPlayer)\\n temp = int(episodeStep < self.args.tempThreshold)\\n\\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = self.game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, self.curPlayer, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n board, self.curPlayer = self.game.getNextState(board, self.curPlayer, action)\\n\\n r = self.game.getGameEnded(board, self.curPlayer)\\n\\n if r != 0:\\n return [(x[0], x[2], r * ((-1) ** (x[1] != self.curPlayer))) for x in trainExamples]\",\n \"def end_episode(self):\\n self.training_buffer.reset_local_buffers()\\n for agent_id in self.episode_steps:\\n self.episode_steps[agent_id] = 0\\n for rewards in self.collected_rewards.values():\\n for agent_id in rewards:\\n rewards[agent_id] = 0\",\n \"def episodes(self):\\n episodes = []\\n for season in self.seasons:\\n episodes.extend(season.episodes)\\n return episodes\",\n \"def executeEpisode(self):\\n trainExamples = []\\n board = self.game.getInitBoard()\\n player = 1\\n episodeStep = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = self.game.getCanonicalForm(board, player)\\n temp = int(episodeStep < self.args.tempThreshold)\\n\\n pi = self.mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = self.game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, player, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n board, player = self.game.getNextState(board, player, action)\\n\\n r = self.game.getGameEnded(board, player)\\n\\n if r != 0:\\n ex = [(x[0], x[2], r * ((-1) ** (x[1] != player))) for x in trainExamples]\\n return ex\",\n \"def episode(agents, t, episode_nr):\\n # Initialize E\\n E = np.zeros((grid_size, grid_size), dtype = int) # Environment, i.e. the grid\\n\\n E[0][3] = 2 # Use for 10x10 grid\\n E[1][3] = 2\\n E[0][6] = 2\\n E[1][6] = 2\\n E[2][6] = 2\\n E[7][3] = 2\\n E[8][3] = 2\\n E[9][3] = 2\\n E[8][6] = 2\\n E[9][6] = 2\\n\\n env_list.append(E)\\n\\n for agent in agents:\\n agent.m = agent.start[0] # Initialize robot position\\n agent.n = agent.start[1] # Initialize robot position\\n E[agent.m][agent.n] = 1 # Initialize robot position on grid\\n agent.carry = False # Initialize robot carry, i.e. the robot does NOT carry cargo\\n agent.steps = 0 # Initialize number of steps taken during episode\\n agent.reward = 0 # Do not reset if we should plot accumulated over all episodes\\n agent.collisions = 0 # Reset number of collisions\\n if episode_nr % 100 == 0:\\n agent.save_target('target_weights_{}.h5'.format(agent.nr))\\n agent.save_policy('policy_weights_{}.h5'.format(agent.nr))\\n\\n terminal = False # Terminal state has not been reached\\n\\n while not terminal: # While agents have not reached their terminal state\\n E, terminal = iterate(agents, E, t, episode_nr)\\n t += 1\\n\\n return t\",\n \"def run_episode(self, environment):\\n state, texts = environment.reset()\\n self.steps_done = 0\\n action = None\\n while True:\\n state_tensor = FloatTensor([state])\\n text_tensor = FloatTensor(texts).mean(dim=0, keepdim=True)\\n action = self.Q.sample_from_softmax_policy(state_tensor, text_tensor)\\n position = self.convert_action(action)\\n (next_state, next_texts), reward, done, _ = environment.step(position)\\n next_text_tensor = FloatTensor(next_texts).mean(dim=0, keepdim=True)\\n for t1 in texts:\\n t1_tensor = FloatTensor([t1])\\n for t2 in next_texts:\\n t2_tensor = FloatTensor([t2])\\n self.memory.push(\\n (state_tensor, t1_tensor, action, t2_tensor,) # action is already a tensor\\n )\\n self.learn(state_tensor, text_tensor, action, next_state, next_text_tensor, reward)\\n state = next_state\\n self.steps_done += 1\\n if done:\\n break\\n history = environment.close()\\n return history\",\n \"def run_all_episodes(self, episode_count):\\n # Holds final result\\n step_arr = []\\n reward_arr = []\\n new_abstr = {}\\n detached_states = []\\n\\n if 'abstraction_type' in self.params.keys() and self.params['abstraction_type'] == 'discretization':\\n self.agent.make_abstraction()\\n\\n while self.episode_count < episode_count:\\n # Run episode, record results\\n steps, reward = self.run_episode()\\n step_arr.append(steps)\\n reward_arr.append(reward)\\n self.episode_count += 1\\n if self.episode_count % 1 == 0:\\n print('Episode {} finished with step count {}'.format(self.episode_count, steps))\\n\\n # Create temporal abstraction if applicable\\n if 'make_abstraction' in self.params.keys() and self.episode_count in self.params['make_abstraction']:\\n self.agent.make_abstraction()\\n new_abstr = self.agent.params['s_a'].abstr_dict\\n\\n # Detach states if applicable\\n if 'refine_abstraction' in self.params.keys() and self.episode_count in self.params['refine_abstraction']:\\n newly_detached = self.agent.refine_abstraction()\\n detached_states.extend(newly_detached)\\n print('final abstraction')\\n for i in range(len(self.agent.params['s_a'].cell_to_abstract_cell)):\\n for key, value in self.agent.params['s_a'].cell_to_abstract_cell[i].items():\\n print(key, value)\\n\\n return step_arr, reward_arr, new_abstr, detached_states\",\n \"def executeEpisode(self, mcts, game, args):\\n trainExamples = []\\n board = game.getInitBoard()\\n curPlayer = 1\\n episodeStep = 0\\n state_counter = Counter()\\n\\n moves = 0\\n\\n while True:\\n episodeStep += 1\\n canonicalBoard = game.getCanonicalForm(board, curPlayer)\\n temp = int(episodeStep < self.args['tempThreshold'])\\n\\n pi = mcts.getActionProb(canonicalBoard, temp=temp)\\n sym = game.getSymmetries(canonicalBoard, pi)\\n for b, p in sym:\\n trainExamples.append([b, curPlayer, p, None])\\n\\n action = np.random.choice(len(pi), p=pi)\\n state_counter.update(game.stringRepresentation(board)) #count the visit to the board\\n\\n board, curPlayer = game.getNextState(board, curPlayer, action)\\n\\n r = game.getGameEnded(board, curPlayer)\\n \\n moves += 1\\n\\n if moves >= self.args['maxMoves']:\\n r = 1e-4\\n\\n if r != 0:\\n return ([(x[0], x[2], r * ((-1) ** (x[1] != curPlayer))) for x in trainExamples], state_counter)\",\n \"def train_by_episode(self):\\n # only REINFORCE and REINFORCE with baseline\\n # use the ff code\\n # convert the rewards to returns\\n rewards = []\\n gamma = 0.99\\n for item in self.memory:\\n [_, _, _, reward, _] = item\\n rewards.append(reward)\\n # rewards = np.array(self.memory)[:,3].tolist()\\n\\n # compute return per step\\n # return is the sum of rewards from t til end of episode\\n # return replaces reward in the list\\n for i in range(len(rewards)):\\n reward = rewards[i:]\\n horizon = len(reward)\\n discount = [math.pow(gamma, t) for t in range(horizon)]\\n return_ = np.dot(reward, discount)\\n self.memory[i][3] = return_\\n\\n # train every step\\n for item in self.memory:\\n self.train(item, gamma=gamma)\",\n \"def on_episode_start(self, agent, **kwargs):\\n self.episode_start[agent.brain.episode] = timeit.default_timer()\\n self.observations[agent.brain.episode] = []\\n self.rewards[agent.brain.episode] = []\\n self.actions[agent.brain.episode] = []\\n self.metrics[agent.brain.episode] = {}\",\n \"def train(self):\\n total_steps = 0\\n scores_history = [deque(maxlen=self.run_settings.averaging_window)\\n for a in range(len(self.agents))]\\n averages_history = [[] for a in range(len(self.agents))]\\n\\n for e in range(self.run_settings.num_episodes):\\n # Initialize episode\\n try:\\n env_states, rewards, done, metainfo = self.custom_env.reset()\\n except EpisodeCrashException:\\n for a in range(len(self.agents)):\\n if hasattr(self.agents[a], 'notify_episode_crashed'):\\n self.agents[a].notify_episode_crashed(self.run_settings)\\n continue\\n\\n # Initialize scores to starting reward (probably 0)\\n scores = rewards\\n step = 0\\n\\n while not done:\\n states = [self.agents[a].state_space_converter(env_states[a])\\n for a in range(len(self.agents))]\\n\\n # Train agents\\n if total_steps > 0 and total_steps % self.run_settings.train_every == 0:\\n for agent in self.agents:\\n agent.train(self.run_settings)\\n\\n # Save agent model\\n if total_steps > 0 and total_steps % self.run_settings.save_every == 0:\\n for agent in self.agents:\\n agent.save()\\n\\n # Get actions\\n actions = [self.agents[a].sample(states[a])\\n for a in range(len(self.agents))]\\n env_actions = [self.agents[a].action_space_converter(actions[a])\\n for a in range(len(self.agents))]\\n # Take environment step\\n try:\\n env_states, rewards, done, metainfo = self.custom_env.step(env_actions)\\n except EpisodeCrashException:\\n for a in range(len(self.agents)):\\n if hasattr(self.agents[a], 'notify_episode_crashed'):\\n self.agents[a].notify_episode_crashed(self.run_settings)\\n break\\n step += 1\\n total_steps += 1\\n\\n # Update scores\\n scores = [scores[a] + rewards[a] for a in range(len(self.agents))]\\n # Push to agent Memories\\n for a in range(len(self.agents)):\\n self.agents[a].push_memory(states[a], actions[a], rewards[a], done)\\n\\n if done:\\n averages = []\\n for a in range(len(scores_history)):\\n scores_history[a].append(scores[a])\\n averages.append(np.mean(scores_history[a]))\\n averages_history[a].append(averages[a])\\n\\n if len(scores) == 1:\\n scores = scores[0]\\n averages = averages[0]\\n if self.run_settings.verbose:\\n print(\\\"Game {} ended after {} steps. Game score: {}. Averages: {}\\\"\\n .format(e+1, step, scores, averages))\\n if (self.run_settings.graph_every > 0 and e > 0\\n and e % self.run_settings.graph_every == 0):\\n self.plot_results(averages_history)\",\n \"def run_episode(self, environment):\\n state = environment.reset()\\n self.steps_done = 0\\n while True:\\n state_tensor = FloatTensor([state])\\n position = self.Q.sample_from_softmax_policy(state_tensor)\\n action = position + 1\\n next_state, reward, done, _ = environment.step(position.item())\\n self.memory.push((state_tensor, action,))\\n self.learn(state_tensor, action, next_state, reward)\\n state = next_state\\n self.steps_done += 1\\n if done:\\n break\\n history = environment.close()\\n return history\",\n \"def test(self):\\n total_steps = 0\\n running_scores = np.zeros(len(self.agents))\\n\\n for e in range(self.run_settings.test_episodes):\\n # Initialize episode\\n try:\\n env_states, rewards, done, metainfo = self.custom_env.reset()\\n except EpisodeCrashException:\\n print('Episode crashed, resetting.')\\n continue\\n\\n # Initialize scores to starting reward (probably 0)\\n scores = np.array(rewards)\\n step = 0\\n\\n while not done:\\n states = [self.agents[a].state_space_converter(env_states[a])\\n for a in range(len(self.agents))]\\n\\n # Get actions\\n actions = [self.agents[a].sample(states[a])\\n for a in range(len(self.agents))]\\n env_actions = [self.agents[a].action_space_converter(actions[a])\\n for a in range(len(self.agents))]\\n if self.run_settings.verbose:\\n self.print_action(env_actions)\\n # Take environment step\\n try:\\n env_states, rewards, done, metainfo = self.custom_env.step(env_actions)\\n except EpisodeCrashException:\\n print('Episode crashed, resetting.')\\n break\\n step += 1\\n total_steps += 1\\n\\n # Update scores\\n scores += np.array(rewards)\\n\\n if done:\\n running_scores += scores\\n\\n if len(scores) == 1:\\n scores = scores[0]\\n if self.run_settings.verbose:\\n print(\\\"Game {} ended after {} steps. Game score: {}\\\"\\n .format(e+1, step, scores))\\n if self.run_settings.verbose:\\n print(\\\"Average game scores: {}\\\".format(running_scores / self.run_settings.test_episodes))\",\n \"def add_episode(self, ep):\\n #make da season\\n ses = self._add_season(ep)\\n dvdses = self._add_season(ep, dvd=True) \\n self._add_episode(ep, ses)\\n self._add_episode(ep, dvdses, dvd=True)\",\n \"def on_episode_end(self, agent, **kwargs):\\n episode = agent.brain.episode\\n duration = timeit.default_timer() - self.episode_start[episode]\\n episode_steps = len(self.observations[episode])\\n\\n # Format all metrics.\\n metrics = self.metrics[episode]\\n\\n nb_step_digits = str(int(np.ceil(np.log10(self.nb_steps))) + 1)\\n template = '{step: ' + nb_step_digits + 'd}/{nb_steps}: episode: {episode}, duration: {duration: 5.3f}s, episode steps: {episode_steps: 5d}, steps per second: {sps: 5.0f}, episode reward: {episode_reward: 10.3f}, mean reward: {reward_mean: 7.3f} [{reward_min: 10.3f}, {reward_max: 10.3f}], mean action: {action_mean: 5.3f} [{action_min: 5.3f}, {action_max: 5.3f}], mean observation: {obs_mean: 5.3f} [{obs_min: 5.3f}, {obs_max: 5.3f}], {metrics}'\\n variables = {\\n 'step': self.step,\\n 'nb_steps': self.nb_steps,\\n 'episode': episode + 1,\\n 'duration': duration,\\n 'episode_steps': episode_steps,\\n 'sps': float(episode_steps) / duration,\\n 'episode_reward': np.sum(self.rewards[episode]),\\n 'reward_mean': np.mean(self.rewards[episode]),\\n 'reward_min': np.min(self.rewards[episode]),\\n 'reward_max': np.max(self.rewards[episode]),\\n 'action_mean': np.mean(self.actions[episode]),\\n 'action_min': np.min(self.actions[episode]),\\n 'action_max': np.max(self.actions[episode]),\\n 'obs_mean': np.mean(self.observations[episode]),\\n 'obs_min': np.min(self.observations[episode]),\\n 'obs_max': np.max(self.observations[episode]),\\n 'metrics': \\\", \\\".join([\\\"{}: {: 10.3f}\\\".format(metrics_key, np.mean(metrics_values))\\n for metrics_key, metrics_values in metrics.items()]),\\n }\\n print(template.format(**variables))\\n\\n # Free up resources.\\n del self.episode_start[episode]\\n del self.observations[episode]\\n del self.rewards[episode]\\n del self.actions[episode]\\n del self.metrics[episode]\",\n \"def RunEpisode(env, policy, eps):\\n\\n obs = env.reset()\\n memory = []\\n R = 0\\n for t in range(1000):\\n action = policy(obs.astype('float32').reshape(1, 4))[0]\\n# pdb.set_trace()\\n r = np.random.rand()\\n if r<eps:\\n action = np.random.random_integers(0,1, ()).tolist()\\n\\n new_obs, reward, done, info = env.step(action)\\n memory.append((obs, action, new_obs, reward, done))\\n obs = new_obs\\n if done:\\n break\\n\\n return memory\",\n \"def run_episode(self, deterministic=False):\\n\\n\\n obs = self.env.reset()\\n Observations, Actions, Rewards = [], [], [] # original trajectory\\n n_Observations, n_Rewards = [], [] # normalized trajectory\\n done = False\\n timestep = 0\\n while not done and timestep < self.episode_horizon:\\n Observations.append(obs)\\n if self.state_preprocessor:\\n n_obs = self.state_preprocessor.get_scaled_x(obs)\\n else:\\n n_obs = obs\\n n_Observations.append(n_obs)\\n action = self.policy.get_action(obs.astype(np.float32).reshape((1,-1)), deterministic=deterministic)\\n Actions.append(action.flatten())\\n obs, reward, done, _ = self.env.step(np.squeeze(action, axis=0))\\n Rewards.append(reward)\\n if self.reward_preprocessor:\\n n_reward = self.reward_preprocessor.get_scaled_x(reward)\\n else:\\n n_reward = reward\\n n_Rewards.append(n_reward)\\n timestep += 1\\n\\n \\n # append the last state\\n Observations.append(obs)\\n if self.state_preprocessor:\\n n_obs = self.state_preprocessor.get_scaled_x(obs)\\n else:\\n n_obs = obs\\n n_Observations.append(n_obs)\\n\\n unscaled_traj = {\\\"Observations\\\": np.array(Observations), \\\"Actions\\\": np.array(Actions), \\\"Rewards\\\": np.array(Rewards)}\\n scaled_traj = {\\\"Observations\\\": np.array(n_Observations), \\\"Actions\\\": np.array(Actions), \\\"Rewards\\\": np.array(n_Rewards)}\\n\\n # update preprocessers\\n if self.state_preprocessor:\\n self.state_preprocessor.update(unscaled_traj['Observations'])\\n # save preprocessor params for restoration\\n self.state_preprocessor.save_params(os.path.join(self.logger.info_dir, \\\"state_preprocessor_params.pkl\\\"))\\n if self.reward_preprocessor:\\n self.reward_preprocessor.update(unscaled_traj['Rewards'])\\n self.reward_preprocessor.save_params(os.path.join(self.logger.info_dir, \\\"reward_preprocessor_params.pkl\\\"))\\n \\n return unscaled_traj, scaled_traj\",\n \"def collect_episode_batch(policy, *,\\n env,\\n batch_size,\\n n_workers=4):\\n sampler = get_sampler(policy, env=env, n_workers=n_workers)\\n agent_update = policy.get_param_values()\\n episodes = sampler.obtain_samples(0, batch_size, agent_update)\\n return episodes\",\n \"def run_episode(env, agent, deterministic, do_training=True, rendering=False, max_timesteps=1000):\\n\\n stats = EpisodeStats() # save statistics like episode reward or action usage\\n state = env.reset()\\n\\n step = 0\\n while True:\\n\\n action_id = agent.act(state=state, deterministic=deterministic)\\n next_state, reward, terminal, info = env.step(action_id)\\n\\n if do_training:\\n agent.train(state, action_id, next_state, reward, terminal)\\n\\n state = next_state\\n\\n # # NOTE reward shaping...\\n # if terminal:\\n # reward += -1\\n # if step < 20:\\n # reward += -10\\n # if step > 100:\\n # reward += 10\\n\\n stats.step(reward, action_id)\\n\\n if rendering:\\n env.render()\\n\\n if terminal or step > max_timesteps:\\n break\\n\\n step += 1\\n\\n return stats\",\n \"def _get_episodes(self):\\n return [series_episode for series_episode in SeriesEpisode.objects.filter(series=self)]\",\n \"def _end_episode(self):\\n self.turn_cnt = 0\\n self.episode_cnt += 1\\n self.contexts = None\\n self.seed_utterances = None\\n self.reset_agents()\",\n \"def episode(self, n):\\n rewards = []\\n for i in range(n):\\n self.episode_n += 1\\n self.state = self.env.reset()\\n self.agent.new_episode(self.state)\\n self.total_reward = 0.0\\n t = 0\\n for t in range(self.max_episode_len):\\n terminate = self.step()\\n if terminate:\\n break\\n logging.warning(\\\"Episode %d finished after %d steps, total reward=%f\\\", self.episode_n, t+1,\\n self.total_reward)\\n summary = tf.Summary()\\n summary.value.add(tag=\\\"episode_total_reward\\\", simple_value=self.total_reward)\\n summary.value.add(tag=\\\"epsisode_success\\\", simple_value=self.flag_success)\\n self.summary_writer.add_summary(summary, self.episode_n)\\n rewards.append(self.total_reward)\\n if self.savedir is not None:\\n self.steps_saver.end_save()\\n return rewards\",\n \"def record_episode(env: Env, policy: Policy, max_steps=10000) -> List[Interaction]:\\n episode = []\\n obs = env.reset()\\n\\n for i in range(max_steps):\\n action = policy.choose_action(obs)\\n next_obs, reward, done, _ = env.step(action)\\n episode.append(Interaction(obs, action, reward))\\n if done:\\n return episode\\n obs = next_obs\\n raise Exception(\\\"Episode did not terminate.\\\")\",\n \"def generate_episode(env, args, render=False, test_mode=False):\\n episode = []\\n state, done = env.reset(), False\\n observations = transform_obs(env.get_all_observations())\\n n_steps = 0\\n\\n for agent in env.agents: # for agents where it matters,\\n agent.set_hidden_state() # set the init hidden state of the RNN\\n\\n while not done:\\n unavailable_actions = env.get_unavailable_actions()\\n \\n # compute action, keep record of hidden state of the agents to store in experience\\n actions, hidden, next_hidden = {}, [], []\\n for idx, agent in enumerate(env.agents):\\n hidden.append(agent.get_hidden_state())\\n actions[agent] = agent.act(observations[idx, :], test_mode=test_mode)\\n next_hidden.append(agent.get_hidden_state())\\n\\n if render:\\n print(f\\\"Step {n_steps}\\\")\\n env.render()\\n print([action.name for action in actions.values()])\\n\\n next_state, rewards, done, _ = env.step(actions)\\n next_obs = transform_obs(env.get_all_observations())\\n \\n # episodes that take long are not allowed and penalized for both agents\\n n_steps += 1\\n if n_steps > args.max_episode_length:\\n done = True\\n rewards = {'blue': -1, 'red': -1}\\n\\n actions = torch.tensor([action.id for action in actions.values()])\\n unavail_actions = torch.zeros((args.n_agents, args.n_actions), dtype=torch.long)\\n for idx, agent in enumerate(env.agents):\\n act_ids = [act.id for act in unavailable_actions[agent]]\\n unavail_actions[idx, act_ids] = 1.\\n \\n episode.append(Experience(transform_state(state), actions, rewards, \\n transform_state(next_state), done, \\n observations, torch.stack(hidden), \\n next_obs, torch.stack(next_hidden),\\n unavail_actions))\\n \\\"\\\"\\\"\\n episode.append(Experience(None, actions, rewards, \\n None, done, \\n observations, torch.stack(hidden), \\n next_obs, torch.stack(next_hidden),\\n unavail_actions))\\n \\\"\\\"\\\" \\n state = next_state\\n observations = next_obs\\n \\n if render:\\n print(f\\\"Game won by team {env.terminal(next_state)}\\\")\\n return episode\",\n \"def inspect(self, save_imgs=True):\\n if 'data' in self.path:\\n outdir = (self.path).replace('data/', 'data_out/')\\n elif 'goals' in self.path:\\n outdir = (self.path).replace('goals/', 'goals_out/')\\n if os.path.exists(outdir):\\n import shutil\\n print(f'Removing: {outdir}')\\n shutil.rmtree(outdir)\\n os.makedirs(outdir)\\n print(f'Saving to: {outdir}')\\n print(f'episode_set: {self.episode_set}')\\n print(f'num_episodes: {self.num_episodes}')\\n\\n def _load(i_ep, episode_len, field):\\n field_path = os.path.join(self.path, field)\\n fname = f'{i_ep:06d}-{episode_len}.pkl'\\n return pickle.load(open(os.path.join(field_path, fname), 'rb'))\\n\\n # For data analysis later to evalute demonstrator quality. Anything for\\n # 'maxlen_stats' should only be applied on episodes with max length.\\n ep_lengths = []\\n all_stats = defaultdict(list)\\n maxlen_stats = defaultdict(list)\\n\\n for i_ep in range(self.num_episodes):\\n if i_ep % 20 == 0:\\n print(f'\\\\ton episode {i_ep}')\\n\\n # is_episode_sample: list of [F,F,T,T,F,F,..], T for this epis only.\\n is_episode_sample = np.int32(self.episode_id) == i_ep\\n episode_samples = np.argwhere(is_episode_sample).squeeze().reshape(-1)\\n episode_len = len(episode_samples)\\n ep_lengths.append(episode_len)\\n color_l = _load(i_ep, episode_len, 'color')\\n depth_l = _load(i_ep, episode_len, 'depth')\\n info_l = _load(i_ep, episode_len, 'info')\\n\\n # Save images if desired, but can take a lot of time.\\n if save_imgs:\\n self._save_images(episode_len, color_l, depth_l, info_l, outdir, i_ep)\\n\\n # ---------------------------------------------------------------- #\\n # If we have 'last' info, we should use it. Should apply to any\\n # data generated on August 12 or later. As of Aug 28, I changed it\\n # so `last_info` will save everything in the `info`, NOT just the\\n # 'extras' key (needed for goal conditioning).\\n # ---------------------------------------------------------------- #\\n if not os.path.exists(os.path.join(self.path, 'last_info')):\\n continue\\n last_color = _load(i_ep, episode_len, 'last_color')\\n last_depth = _load(i_ep, episode_len, 'last_depth')\\n last_info = _load(i_ep, episode_len, 'last_info')\\n\\n # Add stuff to `ep_` lists.\\n self._track_data_statistics(info_l, last_info, episode_len,\\n all_stats, maxlen_stats)\\n\\n if save_imgs:\\n # See transporter.py, mirroring Transporter.get_heightmap().\\n obs_input = {'color': last_color, 'depth': last_depth}\\n colormap, heightmap = get_heightmap(obs_input)\\n heightmap_proc = process_depth(img=heightmap)\\n\\n # Same as earlier, fusing images together.\\n c_img_front = last_color[0] # Shape (480, 640, 3)\\n c_img_front = cv2.resize(c_img_front, (426,320)) # numpy shape: (320,426)\\n barrier = np.zeros((320,4,3)) # Black barrier of 4 pixels\\n combo = np.concatenate((\\n cv2.cvtColor(c_img_front, cv2.COLOR_BGR2RGB),\\n barrier,\\n cv2.cvtColor(colormap, cv2.COLOR_RGB2BGR),\\n barrier,\\n heightmap_proc),\\n axis=1)\\n\\n # Optionally include title with more details, but env dependent.\\n suffix_all = f'{i_ep:06d}-{episode_len:02d}-FINAL.png'\\n suffix_all = self._change_name(suffix_all, last_info['extras'])\\n cv2.imwrite(os.path.join(outdir,suffix_all), combo)\\n # ---------------------------------------------------------------- #\\n\\n # Debugging / inspection. First, debug all episodes.\\n max_l = get_max_episode_len(self.path)\\n ep_lengths = np.array(ep_lengths)\\n print(f'\\\\nStats over {self.num_episodes} demos:')\\n print(f'ep len avg: {np.mean(ep_lengths):0.3f} +/- {np.std(ep_lengths):0.1f}')\\n print(f'ep len median: {np.median(ep_lengths):0.3f}')\\n print(f'ep len min/max: {np.min(ep_lengths)}, {np.max(ep_lengths)}')\\n num_max = np.sum(ep_lengths == max_l)\\n print(f'ep equal to max len ({max_l}): {num_max} / {self.num_episodes}')\\n print('You can approximate this as failures, but might overcount).\\\\n')\\n\\n # Consider env-specific properties, prefacing with [maxlen] as needed.\\n # Though we'll get NaNs if no episodes got to the max -- but thats OK. :)\\n print('Now environment-specific statistics:')\\n\\n if 'cable-shape' in self.path or 'cable-line-notarget' in self.path:\\n # For these tasks, I want to see performance as a function of nb_sides.\\n low, high = 1, 1 # for cable-line-notarget (one side only)\\n if 'cable-shape' in self.path:\\n low, high = 2, 4\\n for nb_sides in range(low, high + 1):\\n md = maxlen_stats[f'done_{nb_sides}']\\n mf = maxlen_stats[f'frac_{nb_sides}']\\n ad = all_stats[f'done_{nb_sides}']\\n af = all_stats[f'frac_{nb_sides}']\\n al = all_stats[f'len_{nb_sides}']\\n print(f'[maxlen] {nb_sides}_done: {np.sum(md)} / {len(md)}')\\n print(f'[maxlen] {nb_sides}_frac: {np.mean(mf):0.3f} +/- {np.std(mf):0.1f}')\\n print(f'[alleps] {nb_sides}_done: {np.sum(ad)} / {len(ad)}')\\n print(f'[alleps] {nb_sides}_frac: {np.mean(af):0.3f} +/- {np.std(af):0.1f}')\\n print(f'[alleps] {nb_sides}_len: {np.mean(al):0.2f} +/- {np.std(al):0.1f}\\\\n')\\n\\n elif 'cable-ring' in self.path:\\n # A bit tricky to interpret area, so I am using percentage improvement.\\n md = maxlen_stats['done']\\n mf = maxlen_stats['fraction']\\n mf_c = maxlen_stats['fraction_delta']\\n ma_pi = maxlen_stats['percent_improve']\\n ad = all_stats['done']\\n af = all_stats['fraction']\\n af_c = all_stats['fraction_delta']\\n aa_pi = all_stats['percent_improve']\\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\\n print(f'[maxlen] fraction: {np.mean(mf):0.3f} +/- {np.std(mf):0.1f}')\\n print(f'[maxlen] f-delta: {np.mean(mf_c):0.3f} +/- {np.std(mf_c):0.1f}')\\n print(f'[maxlen] % area: {np.mean(ma_pi):0.3f} +/- {np.std(ma_pi):0.1f}')\\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\\n print(f'[alleps] fraction: {np.mean(af):0.3f} +/- {np.std(af):0.1f}')\\n print(f'[alleps] f-delta: {np.mean(af_c):0.3f} +/- {np.std(af_c):0.1f}')\\n print(f'[alleps] % area: {np.mean(aa_pi):0.3f} +/- {np.std(aa_pi):0.1f}')\\n\\n elif 'cloth-flat' in self.path:\\n # Report coverage deltas for `cloth-flat` and `cloth-flat-notarget`.\\n md = maxlen_stats['done']\\n mc = maxlen_stats['cloth_coverage']\\n mc_d = maxlen_stats['coverage_delta']\\n ad = all_stats['done']\\n ac = all_stats['cloth_coverage']\\n ac_d = all_stats['coverage_delta']\\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\\n print(f'[maxlen] cov-final: {np.mean(mc):0.3f} +/- {np.std(mc):0.1f}')\\n print(f'[maxlen] cov-delta: {np.mean(mc_d):0.3f} +/- {np.std(mc_d):0.1f}')\\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\\n print(f'[alleps] cov-final: {np.mean(ac):0.3f} +/- {np.std(ac):0.1f}')\\n print(f'[alleps] cov-delta: {np.mean(ac_d):0.3f} +/- {np.std(ac_d):0.1f}')\\n\\n elif 'cloth-cover' in self.path:\\n # As of Aug 12, this env should have all rollouts with 2 actions.\\n md = maxlen_stats['done']\\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\\n\\n elif 'bag-alone-open' in self.path:\\n # Similar to cable-ring.\\n md = maxlen_stats['done']\\n mf = maxlen_stats['fraction']\\n mf_c = maxlen_stats['fraction_delta']\\n ma_pi = maxlen_stats['percent_improve']\\n ad = all_stats['done']\\n af = all_stats['fraction']\\n af_c = all_stats['fraction_delta']\\n aa_pi = all_stats['percent_improve']\\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\\n print(f'[maxlen] fraction: {np.mean(mf):0.3f} +/- {np.std(mf):0.1f}')\\n print(f'[maxlen] f-delta: {np.mean(mf_c):0.3f} +/- {np.std(mf_c):0.1f}')\\n print(f'[maxlen] % area: {np.mean(ma_pi):0.3f} +/- {np.std(ma_pi):0.1f}')\\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\\n print(f'[alleps] fraction: {np.mean(af):0.3f} +/- {np.std(af):0.1f}')\\n print(f'[alleps] f-delta: {np.mean(af_c):0.3f} +/- {np.std(af_c):0.1f}')\\n print(f'[alleps] % area: {np.mean(aa_pi):0.3f} +/- {np.std(aa_pi):0.1f}')\\n\\n elif 'bag-items-easy' in self.path or 'bag-items-hard' in self.path:\\n # Unlike other tasks, here we already did heavy data filtering beforehand.\\n md = maxlen_stats['done']\\n m_ts = maxlen_stats['task_stage']\\n m_zi = maxlen_stats['zone_items_rew']\\n m_zb = maxlen_stats['zone_beads_rew']\\n ad = all_stats['done']\\n a_ts = all_stats['task_stage']\\n a_zi = all_stats['zone_items_rew']\\n a_zb = all_stats['zone_beads_rew']\\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\\n print(f'[maxlen] task_stage: {np.mean(m_ts):0.3f} +/- {np.std(m_ts):0.1f}')\\n print(f'[maxlen] zone_items: {np.mean(m_zi):0.3f} +/- {np.std(m_zi):0.1f}')\\n print(f'[maxlen] zone_beads: {np.mean(m_zb):0.3f} +/- {np.std(m_zb):0.1f}')\\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\\n print(f'[alleps] task_stage: {np.mean(a_ts):0.3f} +/- {np.std(a_ts):0.1f}')\\n print(f'[alleps] zone_items: {np.mean(a_zi):0.3f} +/- {np.std(a_zi):0.1f}')\\n print(f'[alleps] zone_beads: {np.mean(a_zb):0.3f} +/- {np.std(a_zb):0.1f}')\\n\\n elif 'bag-color-goal' in self.path:\\n # Also does data filtering beforehand.\\n md = maxlen_stats['done']\\n m_ts = maxlen_stats['task_stage']\\n m_th = maxlen_stats['frac_in_target_bag']\\n m_dh = maxlen_stats['frac_in_distract_bag']\\n ad = all_stats['done']\\n a_ts = all_stats['task_stage']\\n a_th = all_stats['frac_in_target_bag']\\n a_dh = all_stats['frac_in_distract_bag']\\n print(f'[maxlen] done: {np.sum(md)} / {len(md)}')\\n print(f'[maxlen] task_stage: {np.mean(m_ts):0.3f} +/- {np.std(m_ts):0.1f}')\\n print(f'[maxlen] frac_target_bag: {np.mean(m_th):0.3f} +/- {np.std(m_th):0.1f}')\\n print(f'[maxlen] frac_distract_bag: {np.mean(m_dh):0.3f} +/- {np.std(m_dh):0.1f}')\\n print(f'[alleps] done: {np.sum(ad)} / {len(ad)}')\\n print(f'[alleps] task_stage: {np.mean(a_ts):0.3f} +/- {np.std(a_ts):0.1f}')\\n print(f'[alleps] frac_target_bag: {np.mean(a_th):0.3f} +/- {np.std(a_th):0.1f}')\\n print(f'[alleps] frac_distract_bag: {np.mean(a_dh):0.3f} +/- {np.std(a_dh):0.1f}')\",\n \"def episode_to_transitions_pose_toy(episode_data):\\n # This is just saving data for a supervised regression problem, so obs_tp1\\n # can be discarded.\\n transitions = []\\n for transition in episode_data:\\n (obs_t, action, reward, obs_tp1, done, debug) = transition\\n del obs_tp1\\n del done\\n features = {}\\n obs_t = Image.fromarray(obs_t)\\n features['state/image'] = _bytes_feature([image.jpeg_string(obs_t)])\\n features['pose'] = _float_feature(action.flatten().tolist())\\n features['reward'] = _float_feature([reward])\\n features['target_pose'] = _float_feature(debug['target_pose'].tolist())\\n transitions.append(\\n tf.train.Example(features=tf.train.Features(feature=features)))\\n return transitions\",\n \"def end_episode(self):\\n self.training_buffer.reset_all()\\n for agent_id in self.cumulative_rewards:\\n self.cumulative_rewards[agent_id] = 0\\n for agent_id in self.episode_steps:\\n self.episode_steps[agent_id] = 0\\n if self.use_curiosity:\\n for agent_id in self.intrinsic_rewards:\\n self.intrinsic_rewards[agent_id] = 0\",\n \"def stopEpisode(self):\\n if self.episodesSoFar < self.numTraining:\\n self.accumTrainRewards += self.episodeRewards\\n else:\\n self.accumTestRewards += self.episodeRewards\\n self.episodesSoFar += 1\\n if self.episodesSoFar >= self.numTraining:\\n # Take off the training wheels\\n self.epsilon = 0.0 # no exploration\\n self.alpha = 0.0 # no learning\\n\\n print(\\\"Agent Stop Episode\\\")\\n print(self.episodeRewards)\\n for feature, weight in self.weights.iteritems():\\n print(\\\"\\\\t\\\" + str(feature) + \\\" - \\\" + str(weight))\\n self.episodeRewardsList.append(self.episodeRewards)\",\n \"def q_learning(env, agent, num_episodes, batch_size, epsilon, epsilon_min, epsilon_decay, folder):\\n \\n # Keeps track of useful statistics\\n stats = plotting.EpisodeStats(\\n episode_lengths=np.zeros(num_episodes),\\n episode_rewards=np.zeros(num_episodes))\\n\\n\\n for i_episode in range(num_episodes):\\n if epsilon > epsilon_min and i_episode > 500:\\n # complete random exploration 500 episodes, \\n # then decrase exploration till epsilon less than epsilon_min\\n epsilon *= epsilon_decay\\n sys.stdout.flush()\\n\\n state = env.reset()\\n state = np.reshape(state, [1, env.nS])\\n\\n \\n for t in range(MAX_STEP):\\n\\n ## Decide action\\n action = agent.act(state, epsilon)\\n ## Advance the game to the next frame based on the action\\n next_state, reward, done, _ = env.step(action)\\n\\n env.my_render(folder)\\n\\n stats.episode_rewards[i_episode] += reward\\n stats.episode_lengths[i_episode] = t+1\\n\\n next_state = np.reshape(next_state, [1, env.nS])\\n ## Remember the previous state, action, reward, and done\\n agent.remember(state, action, reward, next_state, done)\\n ## make next_state the new current state for the next frame.\\n state = next_state ## change to copy.copy(next_state), if it is a array\\n\\n if len(agent.memory) > batch_size:\\n agent.replay(batch_size) \\n\\n if done: \\n break\\n \\n mean_score = stats.episode_rewards[i_episode]/stats.episode_lengths[i_episode]\\n print(\\\"episode: {}/{}, score: {}, e: {:.2}, steps:{}, mean score:{:.2}\\\"\\n .format(i_episode, num_episodes, stats.episode_rewards[i_episode], epsilon, \\n stats.episode_lengths[i_episode], \\n mean_score))\\n #if(i_episode > 200):\\n write_csv(folder, i_episode, stats.episode_lengths[i_episode], mean_score)\\n if(i_episode%50 == 0):\\n agent.save(folder + \\\"_qn\\\" + str(i_episode) + \\\".h5\\\") \\n agent.save(folder + \\\"_qn-final\\\" + \\\".h5\\\") \\n\\n return stats\",\n \"def train_episode(self):\\n state = self.env.reset()\\n states = []\\n actions = []\\n rewards = []\\n for _ in range(self.options.steps):\\n probs = self.actor_baseline.predict([[state]])[0][0]\\n action = np.random.choice(len(probs), p=probs)\\n\\n next_state, reward, done, _ = self.step(action)\\n states.append(state)\\n actions.append(action)\\n rewards.append(reward)\\n\\n state = next_state\\n\\n if done:\\n break\\n\\n # Compute and store returns in G\\n G = np.zeros_like(rewards)\\n ################################\\n # YOUR IMPLEMENTATION HERE #\\n ################################\\n\\n # One-hot encoding for actions\\n actions_one_hot = np.zeros([len(actions), self.env.action_space.n])\\n actions_one_hot[np.arange(len(actions)), actions] = 1\\n\\n # Compute one-hot encoded deltas\\n ################################\\n # YOUR IMPLEMENTATION HERE #\\n ################################\\n deltas = [[0]]\\n\\n # Update actor and state estimator\\n self.actor_baseline.fit(x=[np.array(states)],\\n y={'actor_output': deltas, 'baseline_output': returns},\\n epochs=1, batch_size=self.options.batch_size, verbose=0)\",\n \"def episodes(self):\\n if self._episode_cache_ver == self._db._version:\\n return self._episode_cache\\n\\n # Get only rows from the preferred provider (provider id is not null) except\\n # for season 0 (specials), where we take all episodes.\\n if self.number > 0:\\n idmap = {self.series.provider.IDATTR: db.QExpr('>', u'')}\\n else:\\n idmap = {}\\n dbrows = self._db.query(type='episode', parent=self.series._dbrow, season=self.number, **idmap)\\n self._episode_cache = [Episode(self._db, self.series, self, dbrow) for dbrow in dbrows]\\n self._episode_cache.sort(key=lambda e: e.number)\\n self._episode_cache_ver = self._db._version\\n return self._episode_cache\",\n \"def get_all(self):\\n # s = torch.FloatTensor(self._states).to(device)\\n # a = torch.FloatTensor(self._actions).to(device)\\n # r = torch.FloatTensor(self._rewards).to(device)\\n return self._episodes\",\n \"def run_episode(env, agent, deterministic, skip_frames=0, do_training=True, rendering=True, max_timesteps=10000,\\n history_length=0, manual=False):\\n\\n stats = utils.EpisodeStats()\\n\\n # Save history\\n image_hist = []\\n\\n step = 0\\n state = env.reset()\\n\\n env.viewer.window.on_key_press = utils.key_press\\n env.viewer.window.on_key_release = utils.key_release\\n # fix bug of corrupted states without rendering in gym environment\\n env.viewer.window.dispatch_events()\\n\\n # append image history to first state\\n state = state_preprocessing(state)\\n image_hist.extend([state] * (history_length + 1))\\n state = np.array(image_hist).reshape(96, 96, history_length + 1)\\n while True:\\n #skip intro zoom frames\\n if step < 48:\\n step += 1\\n env.step(utils.id_to_action(0))\\n continue\\n \\n # TODO: get action_id from agent\\n # Hint: adapt the probabilities of the 5 actions for random sampling so that the agent explores properly.\\n if do_training and manual:\\n action_id = utils.manual_action\\n else:\\n action_id = agent.act(state, deterministic)\\n action = utils.id_to_action(action_id)\\n\\n # Hint: frame skipping might help you to get better results.\\n reward = 0\\n for _ in range(skip_frames + 1):\\n next_state, r, terminal, info = env.step(action)\\n reward += r\\n\\n if rendering:\\n env.render()\\n\\n if terminal:\\n break\\n\\n next_state = state_preprocessing(next_state)\\n \\n image_hist.append(next_state)\\n image_hist.pop(0)\\n next_state = np.array(image_hist).reshape(96, 96, history_length + 1)\\n\\n if do_training and (next_state[:82, :, -1].sum() > 5000): #track out of sight\\n print('Track gone; finish this episode')\\n agent.add(state, action_id, next_state, reward=-(skip_frames + 1), terminal=True) #punish\\n break\\n\\n if do_training:\\n agent.add(state, action_id, next_state, reward, terminal)\\n if not manual:\\n agent.train()\\n\\n stats.step(reward, action_id)\\n\\n state = next_state\\n \\n if terminal or (step * (skip_frames + 1)) > max_timesteps:\\n break\\n\\n step += 1\\n\\n return stats\",\n \"def run(self) -> None:\\n for episode in range(1, self.episodes + 1):\\n print('Episode:', episode)\\n steps, state_action_history = self.run_one_episode()\\n self.steps_per_episode.append(steps)\\n if episode % parameters.CACHING_INTERVAL == 0 or steps < 1000:\\n visualize.animate_track(state_action_history, f'agent-{episode}')\\n\\n print('Training completed.')\\n visualize.plot_steps_per_episode(self.steps_per_episode)\\n visualize.plot_epsilon(self.agent.epsilon_history)\\n\\n if parameters.VISUALIZE_FINAL_GAME:\\n print('Showing one episode with the greedy strategy.')\\n self.agent.epsilon = 0\\n steps, state_action_history = self.run_one_episode()\\n print(f'Episode completed in {steps} steps.')\\n visualize.animate_track(state_action_history)\",\n \"def collect(self) -> int:\\n self.get_logger().info('Generating experiences...')\\n # Decay epsilon if requred\\n self._wp.decay_epsilon(self.episode, 0.001)\\n\\n # Generate experiences\\n trajectory_length, total_reward = self.step()\\n self.publish(total_reward)\\n self.flag.shift_to_compute_cycle()\\n\\n # Total reward section\\n self._total_reward += total_reward\\n if (self.episode + 1) % self._update == 0:\\n self.get_logger().error(\\n f'Expected Reward: {self._total_reward / self._update}')\\n self._total_reward = 0\\n\\n return trajectory_length\",\n \"def train_on_history(self, history):\\n \\n # Split into episodes\\n n_episodes = history[-1][\\\"episode\\\"] \\n episodes = [list(filter(lambda h: h[\\\"episode\\\"]==e , history)\\n ) for e in range(n_episodes)\\n ]\\n\\n # Split into game lives\\n for episode in episodes:\\n \\n \\n game_lives = [\\n list(filter(lambda h: h.get('info').get('ale.lives')==l, episode)\\n ) for l in range(5)\\n ]\\n \\n for life in game_lives:\\n if life:\\n self.train(life)\\n else:\\n print(\\\"No ocurrance\\\")\\n return\",\n \"def run(agent, env, num_episodes = 20000, mode = 'train'):\\n\\t scores=[]\\n\\t max_avg_score=-np.inf\\n\\t for i_episode in range(1, num_episodes + 1):\\n\\t # Initialize episode\\n\\t state=env.reset()\\n\\t action=agent.reset_episode(state)\\n\\t total_reward=0\\n\\t done=False\\n\\n\\t # Roll out steps until done\\n\\t while not done:\\n\\t state, reward, done, info=env.step(action)\\n\\t total_reward += reward\\n\\t action=agent.act(state, reward, done, mode)\\n\\n\\t # Save final score\\n\\t scores.append(total_reward)\\n\\n\\t # Print episode stats\\n\\t if mode == 'train':\\n\\t if len(scores) > 100:\\n\\t avg_score=np.mean(scores[-100:])\\n\\t if avg_score > max_avg_score:\\n\\t max_avg_score=avg_score\\n\\n\\t if i_episode % 100 == 0:\\n\\t print(\\\"\\\\rEpisode {}/{} | Max Average Score: {}\\\".format(i_episode,\\n\\t num_episodes, max_avg_score), end = \\\"\\\")\\n\\t sys.stdout.flush()\\n\\n\\t return scores\\n\\n\\tscores=run(q_agent, env)\\n\\n\\t# Plot scores obtained per episode\\n\\tplt.plot(scores); plt.title(\\\"Scores\\\")\\n\\n\\tdef plot_scores(scores, rolling_window = 100):\\n\\t\\t\\\"\\\"\\\"Plot scores and optional rolling mean using specified window.\\\"\\\"\\\"\\n\\t\\tplt.plot(scores); plt.title(\\\"Scores\\\");\\n\\t\\trolling_mean=pd.Series(scores).rolling(rolling_window).mean()\\n\\t\\tplt.plot(rolling_mean);\\n\\t\\treturn rolling_mean\\n\\n\\trolling_mean=plot_scores(scores)\\n\\n\\t# Run in test mode and analyze socres obtained\\n\\ttest_scores=run(q_agent, env, num_episodes = 100, mode = 'test')\\n\\tprint(\\\"[TEST] Completed {} episodes with avg. score = {}\\\".format(\\n\\t len(test_scores), np.mean(test_scores)))\\n\\t_=plot_scores(test_scores, rolling_window = 10)\\n\\n\\n\\tdef plot_q_table(q_table):\\n \\\"\\\"\\\"Visualize max Q-value for each state and corresponding action.\\\"\\\"\\\"\\n\\t q_image=np.max(q_table, axis = 2) # max Q-value for each state\\n\\t q_actions=np.argmax(q_table, axis = 2) # best action for each state\\n\\n\\t fig, ax=plt.subplots(figsize = (10, 10))\\n\\t cax=ax.imshow(q_image, cmap = 'jet');\\n\\t cbar=fig.colorbar(cax)\\n\\t for x in range(q_image.shape[0]):\\n\\t for y in range(q_image.shape[1]):\\n\\t ax.text(x, y, q_actions[x, y], color = 'white',\\n\\t horizontalalignment = 'center', verticalalignment = 'center')\\n\\t ax.grid(False)\\n\\t ax.set_title(\\\"Q-table, size: {}\\\".format(q_table.shape))\\n\\t ax.set_xlabel('position')\\n\\t ax.set_ylabel('velocity')\\n\\n\\n\\tplot_q_table(q_agent.q_table)\\n\\n\\n\\tstate_grid_new=create_uniform_grid(\\n\\t env.observation_space.low, env.observation_space.high, bins = (20, 20))\\n\\tq_agent_new=QLearningAgent(env, state_grid_new)\\n\\tq_agent_new.scores=[]\\n\\n\\n\\tq_agent_new.scores += run(q_agent_new, env,\\n\\t num_episodes = 50000) # accumulate scores\\n\\trolling_mean_new=plot_scores(q_agent_new.scores)\\n\\n\\ttest_scores= run(q_agent_new, env, num_episodes = 100, mode = 'test')\\n\\tprint(\\\"[TEST] Completed {} episodes with avg. score = {}\\\".format(\\n\\t len(test_scores), np.mean(test_scores)))\\n\\t_=plot_scores(test_scores)\\n\\n\\tplot_q_table(q_agent_new.q_table)\\n\\n\\tstate=env.reset()\\n\\tscore=0\\n\\timg=plt.imshow(env.render(mode='rgb_array'))\\n\\tfor t in range(1000):\\n\\t\\taction=q_agent_new.act(state, mode = 'test')\\n\\t\\timg.set_data(env.render(mode='rgb_array'))\\n\\t\\tplt.axis('off')\\n\\t\\tdisplay.display(plt.gcf())\\n\\t\\tdisplay.clear_output(wait = True)\\n\\t\\tstate, reward, done, _=env.step(action)\\n\\t\\tsocre += reward\\n\\t\\tif done:\\n\\t\\t\\tprint('Score: ', socre)\\n\\t\\t\\tbreak\\n\\tenv.close()\",\n \"def __getitem__(self, cur_episode):\\n if self.platform == \\\"win\\\":\\n env = lmdb.open(self.lmdb_file, subdir=False,\\n readonly=True, lock=False,\\n readahead=False, meminit=False)\\n else:\\n env = self.env\\n # episode_set = self.episode_sets[episode]\\n total_support_x = []\\n total_query_x = []\\n total_support_y = []\\n total_query_y = []\\n\\n for t in range(self.t_task):\\n # create a task (n_way*k_shot+ n_way*k_query)\\n\\n support_x = []\\n query_x = []\\n support_y = []\\n query_y = []\\n\\n support_imgs = []\\n query_imgs = []\\n\\n # select n_way classes randomly\\n selected_classes = np.random.choice(self.total_cls, self.n_way)\\n # select k_shot + k_query for each class\\n for selected_class in selected_classes:\\n selected_imgs = np.random.choice(\\n self.dic_img_label[self.num2label[selected_class]], self.k_shot + self.k_query, False)\\n support_imgs += selected_imgs[:self.k_shot].tolist()\\n query_imgs += selected_imgs[self.k_shot:].tolist()\\n\\n with env.begin(write=False) as txn:\\n for i, img_id in enumerate(support_imgs):\\n res = pyarrow.deserialize(txn.get(u'{}'.format(img_id).encode('ascii')))\\n support_x.append(self.transform(res[0]))\\n support_y.append(np.array([self.label2num[res[1]]]))\\n\\n for i, img_id in enumerate(query_imgs):\\n res = pyarrow.deserialize(txn.get(u'{}'.format(img_id).encode('ascii')))\\n query_x.append(self.transform(res[0]))\\n query_y.append(np.array([self.label2num[res[1]]]))\\n support_x = torch.stack(support_x, 0)\\n query_x = torch.stack(query_x, 0)\\n support_y = np.array(support_y)\\n query_y = np.array(query_y)\\n\\n # shuffle:\\n index = np.random.permutation(len(support_y))\\n support_x = support_x[index]\\n if not self.fet_global:\\n support_y = np.array([i for i in range(self.n_way) for j in range(self.k_shot)])\\n support_y = support_y[index]\\n\\n index = np.random.permutation(len(query_y))\\n query_x = query_x[index]\\n if not self.fet_global:\\n query_y = np.array([i for i in range(self.n_way) for j in range(self.k_query)])\\n\\n query_y = query_y[index]\\n\\n # a batch\\n total_query_x.append(query_x)\\n total_query_y.append(query_y)\\n total_support_x.append(support_x)\\n total_support_y.append(support_y)\\n\\n total_query_x = torch.cat(total_query_x, 0)\\n total_query_y = np.hstack(total_query_y)\\n total_support_x = torch.cat(total_support_x, 0)\\n total_support_y = np.hstack(total_support_y)\\n\\n imgs = torch.cat([total_support_x, total_query_x], 0)\\n labels = torch.from_numpy(np.hstack([total_support_y, total_query_y]).reshape([-1, 1]))\\n return imgs, labels\",\n \"def process_results(self, episode, eval):\\n if episode % 10 == 9:\\n ave = np.mean(self.scores[episode - 9:episode])\\n print('Episodes: {}, AveScores: {}, Alpha: {}, Steps: {}'.format(\\n episode + 1, ave, self.alpha.item(), self.step_count))\\n if eval:\\n if episode % 100 == 99:\\n s1 = './' + self.game_name + '/'\\n np.save(s1 + 'scores_eval{}.npy'.format(episode + 1), self.scores)\\n print('Evaluation results saved!')\\n else:\\n if episode % 200 == 199:\\n self.save_episode_models(episode)\\n self.plot_array(episode)\\n print('Model salved!')\\n print('Total {} frames!'.format(self.frames_count))\",\n \"def on_episode_end(self, episode, logs):\\n duration = timeit.default_timer() - self.episode_start[episode]\\n episode_steps = len(self.observations[episode])\\n\\n metrics = np.array(self.metrics[episode])\\n metrics_dict = {}\\n with warnings.catch_warnings():\\n warnings.filterwarnings('error')\\n for idx, name in enumerate(self.metrics_names):\\n try:\\n metrics_dict[name] = np.nanmean(metrics[:, idx])\\n except Warning:\\n metrics_dict[name] = float('nan')\\n\\n wandb.log(\\n {\\n 'step': self.step,\\n 'episode': episode + 1,\\n # 'duration': duration,\\n 'episode_steps': episode_steps,\\n # 'sps': float(episode_steps) / duration,\\n 'episode_reward_sum': np.sum(self.rewards[episode]),\\n 'reward_mean': np.mean(self.rewards[episode]),\\n 'reward_min': np.min(self.rewards[episode]),\\n 'reward_max': np.max(self.rewards[episode]),\\n 'action_mean': np.mean(self.actions[episode]),\\n # 'action_min': np.min(self.actions[episode]),\\n # 'action_max': np.max(self.actions[episode]),\\n # 'obs_mean': np.mean(self.observations[episode]),\\n # 'obs_min': np.min(self.observations[episode]),\\n # 'obs_max': np.max(self.observations[episode]),\\n 'steps': logs['steps'],\\n 'target_reached': logs['target_reached'],\\n 'target_reached_in_steps': logs['target_reached_in_steps'],\\n 'episode_reward': logs['episode_reward'],\\n **metrics_dict\\n }\\n )\\n\\n # Free up resources.\\n del self.episode_start[episode]\\n del self.observations[episode]\\n del self.rewards[episode]\\n del self.actions[episode]\\n del self.metrics[episode]\",\n \"def episodes(self):\\n for episode in self._root.iter('Episode'):\\n entry = {}\\n entry['season'] = int(episode.find('SeasonNumber').text)\\n entry['episode'] = int(episode.find('EpisodeNumber').text)\\n entry['title'] = unicode(episode.find('EpisodeName').text)\\n if entry['title'] == '':\\n continue\\n entry['description'] = unicode(episode.find('Overview').text)\\n entry['firstAired'] = episode.find('FirstAired').text\\n yield entry\",\n \"def on_step_end(self, step, logs):\\n episode = logs['episode']\\n self.observations[episode].append(logs['observation'])\\n self.rewards[episode].append(logs['reward'])\\n self.actions[episode].append(logs['action'])\\n self.metrics[episode].append(logs['metrics'])\\n self.step += 1\",\n \"def on_step_end(self, step, logs):\\n episode = logs['episode']\\n self.observations[episode].append(logs['observation'])\\n self.rewards[episode].append(logs['reward'])\\n self.actions[episode].append(logs['action'])\\n self.metrics[episode].append(logs['metrics'])\\n self.step += 1\",\n \"def run(self):\\n data_provider = DataProvider(self.config)\\n hex_attr_df = data_provider.read_hex_bin_attributes()\\n hex_distance_df = data_provider.read_hex_bin_distances()\\n city_states = data_provider.read_city_states(self.city_states_filename)\\n neighborhood = data_provider.read_neighborhood_data()\\n popular_bins = data_provider.read_popular_hex_bins()\\n num_episodes = self.config['RL_parameters']['num_episodes']\\n ind_episodes = self.config['RL_parameters']['ind_episodes']\\n exp_decay_multiplier = self.config['RL_parameters']['exp_decay_multiplier']\\n\\n q_ind = None\\n r_table = None\\n xi_matrix = None\\n\\n best_episode = None\\n best_model = {}\\n\\n progress_bar = tqdm(xrange(num_episodes))\\n for episode_id in progress_bar:\\n progress_bar.set_description(\\\"Episode: {}\\\".format(episode_id))\\n current_best = -1000000\\n\\n # Create episode\\n ind_exploration_factor = np.e ** (-1 * episode_id * exp_decay_multiplier / ind_episodes)\\n\\n episode = Episode(self.config,\\n episode_id,\\n ind_exploration_factor,\\n hex_attr_df,\\n hex_distance_df,\\n city_states,\\n neighborhood,\\n popular_bins,\\n q_ind,\\n r_table,\\n xi_matrix)\\n\\n # Run episode\\n tables = episode.run()\\n q_ind = tables['q_ind']\\n r_table = tables['r_table']\\n xi_matrix = tables['xi_matrix']\\n episode_tracker = tables['episode_tracker']\\n\\n # Uncomment for logging if running a job, comment during experiments\\n # otherwise it leads to insanely huge logging output which is useless\\n\\n # self.logger.info(\\\"\\\"\\\"\\n # Expt: {} Episode: {} Earnings: {}\\n # Pax rides: {} Relocation rides: {} Unmet demand: {}\\n # \\\"\\\"\\\".format(self.expt_name, episode_id,\\n # episode_tracker.gross_earnings,\\n # episode_tracker.successful_waits,\\n # episode_tracker.relocation_rides,\\n # episode_tracker.unmet_demand))\\n # self.logger.info(\\\"----------------------------------\\\")\\n\\n self.training_tracker.update_RL_tracker(\\n episode_id, episode_tracker.gross_earnings,\\n episode_tracker.successful_waits, episode_tracker.unsuccessful_waits,\\n episode_tracker.unmet_demand, episode_tracker.relocation_rides,\\n episode_tracker.DET, episode_tracker.DPRT, episode_tracker.DWT,\\n episode_tracker.DRT, episode_tracker.DCT)\\n\\n # Keep track of the best episode\\n if self.objective == 'revenue':\\n if episode_tracker.gross_earnings >= current_best:\\n best_episode = episode_tracker\\n current_best = best_episode.gross_earnings\\n else: # self.objective == 'pickups':\\n if episode_tracker.successful_waits >= current_best:\\n best_episode = episode_tracker\\n current_best = episode_tracker.successful_waits\\n\\n # Keep track of the best model\\n best_model['ind_exploration_factor'] = ind_exploration_factor\\n best_model['config'] = self.config\\n best_model['q_ind'] = q_ind\\n best_model['r_table'] = r_table\\n best_model['xi_matrix'] = xi_matrix\\n best_model['training_tracker'] = self.training_tracker\\n\\n # After finishing training\\n self.logger.info(\\\"Expt: {} Earnings: {} Met Demand: {} Unmet Demand: {}\\\".format(self.expt_name,\\n best_episode.gross_earnings,\\n best_episode.successful_waits,\\n best_episode.unmet_demand))\\n return best_episode, best_model, self.training_tracker\",\n \"def ddpg(n_episodes=1000, print_every=50):\\r\\n \\r\\n scores = []\\r\\n scores_deque = deque(maxlen=print_every)\\r\\n log = open(\\\"log.txt\\\",\\\"w+\\\")\\r\\n for i_episode in range(1, n_episodes+1):\\r\\n env_info = env.reset(train_mode=True)[BRAIN_NAME]\\r\\n agent.reset()\\r\\n state = env_info.vector_observations # get the current state\\r\\n score = np.zeros(NUM_AGENTS)[:, None] \\r\\n \\r\\n while True:\\r\\n action = agent.act(state) # select an action\\r\\n env_info = env.step(action)[BRAIN_NAME] # send the action to the environment\\r\\n next_state = env_info.vector_observations # get the next state\\r\\n reward = np.array(env_info.rewards)[:, None] # get the reward\\r\\n done = np.array(env_info.local_done )[:, None] # see if episode has finished\\r\\n agent.step(state, action, reward, next_state, done) # take step with agent (including learning)\\r\\n score += reward # update the score\\r\\n state = next_state # roll over the state to next time step\\r\\n if np.any(done): \\r\\n break\\r\\n scores_deque.append(score.mean()) \\r\\n scores.append(score.mean()) \\r\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)), end=\\\"\\\")\\r\\n if i_episode % print_every == 0:\\r\\n string ='\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque))\\r\\n print(string)\\r\\n log.write(string)\\r\\n torch.save(agent.actor_local.state_dict(), 'checkpoint_actor.pth')\\r\\n torch.save(agent.critic_local.state_dict(), 'checkpoint_critic.pth')\\r\\n \\r\\n if np.mean(scores_deque)>=30.0 and i_episode>=100:\\r\\n print('\\\\nEnvironment solved in {:d} episodes!\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)))\\r\\n torch.save(agent.actor_local.state_dict(), 'checkpoint_actor.pth')\\r\\n torch.save(agent.critic_local.state_dict(), 'checkpoint_critic.pth')\\r\\n break\\r\\n log.close()\\r\\n return scores\",\n \"def run_episode(self):\\n self.pygame_clock = pygame.time.Clock()\\n while True:\\n pygame.event.pump()\\n is_human_agent = isinstance(self.agents[self.env.turn], HumanAgent)\\n\\n # handle exit event\\n self.handle_input_event()\\n\\n # pick the next action\\n if is_human_agent:\\n self.handle_input_event()\\n else:\\n self.ai_event()\\n self.place_a_disk()\\n self.render()\\n\\n if self.event == Event.END_GAME:\\n pygame.time.wait(self.END_GAME_DELAY)\\n\\n if self.event == Event.END_GAME_VIEW:\\n pygame.time.wait(self.END_GAME_VIEW_DELAY)\\n break\",\n \"def _rollout_an_episode(self):\\n self._steps = 0\\n me_id = self._learning_agent_id # short name\\n oppo_id = self._oppo_agent_id # short name\\n logger.log('episode begins with the task: {}'.format(str(self.task)))\\n\\n # passing me and oppo hyperparams to the arena interface\\n assert self.task.hyperparam is not None\\n logger.log('pulling oppo hyperparam of model key {}'.format(\\n self.task.model_key2))\\n oppo_hyperparam = self._model_pool_apis.pull_attr(attr='hyperparam',\\n key=self.task.model_key2)\\n logger.log('Done pulling oppo hyperparam')\\n oppo_inter_kwargs = ({} if oppo_hyperparam is None\\n else oppo_hyperparam.__dict__)\\n inter_kwargs = ([self.task.hyperparam.__dict__]\\n + [oppo_inter_kwargs] * (self.n_agents - 1))\\n\\n # agent, env reset\\n obs = self.env.reset(inter_kwargs=inter_kwargs)\\n for agt, ob in zip(self.agents, obs):\\n agt.reset(ob)\\n self._update_agents_model(self.task) # for agent Neural Net parameters\\n\\n me_reward_sum = 0.0\\n self.time_beg = time.time()\\n self._update_hyperparam(self.task)\\n self._changed_task = False\\n while True:\\n self._steps += 1\\n # predictions for each agent\\n predictions = self._parallel.run((self._agent_pred, ob, i)\\n for i, ob in enumerate(obs))\\n me_prediction = predictions[me_id]\\n me_action, extra_vars = me_prediction[me_id], me_prediction[oppo_id:]\\n # predicted actions for each agent\\n actions = [me_action] + [other_action\\n for other_action in predictions[oppo_id:]]\\n # book-keep obs in previous step\\n last_obs = obs\\n\\n # agent-env interaction\\n obs, reward, done, info = self.env.step(actions)\\n\\n me_rwd_scalar = self._reward_shape(reward[me_id])\\n me_reward_sum += me_rwd_scalar\\n\\n if self._enable_push:\\n # put the interested data (obs, rwd, act, ... for each agent) into the\\n # _data_queue, which is watched in another Thread (the _push_data_to_learner()\\n # method) that the data are dequeued and sent to remote Learner\\n if self._data_queue.full():\\n logger.log(\\\"Actor's queue is full.\\\", level=logger.WARN)\\n rwd_to_push = (me_rwd_scalar if self.rwd_shape\\n else np.asarray(reward[me_id], np.float32))\\n if self.use_oppo_obs:\\n if isinstance(extra_vars, tuple):\\n extra_vars += (self.agents[self._oppo_agent_id]._last_state,)\\n else:\\n extra_vars.append(self.agents[self._oppo_agent_id]._last_state)\\n data_tuple = (last_obs, tuple(actions), rwd_to_push, info, done, extra_vars)\\n self._data_queue.put(data_tuple)\\n logger.log('successfully put one tuple.', level=logger.DEBUG)\\n\\n if self._steps % self._log_interval_steps == 0:\\n logger.log('_rollout_an_episode,', 'steps: {},'.format(self._steps),\\n 'data qsize: {}'.format(self._data_queue.qsize()))\\n\\n if done:\\n # an episode ends\\n if self._replay_dir:\\n self._save_replay()\\n self.log_kvs(me_reward_sum, info)\\n if self._changed_task:\\n return None, info\\n else:\\n return self.log_outcome(info), info\\n\\n if self._update_model_freq and self._steps % self._update_model_freq == 0:\\n # time to update the model for each agent\\n if (self._enable_push and\\n self._model_pool_apis.pull_attr(\\n 'freezetime', self.task.model_key1) is not None):\\n # Current task (learning period) finishes, start a new task or continue\\n self._finish_task(self.task, None) # notify early abort\\n last_task = self.task\\n self.task = self._request_task() # try to continue\\n if not is_inherit(last_task.model_key1, self.task.model_key1):\\n self.log_kvs(me_reward_sum, info)\\n return None, info\\n if last_task.model_key2 != self.task.model_key2:\\n self._changed_task = True\\n self._update_agents_model(self.task)\",\n \"def evolve(self, env, num_generations, num_episodes, num_frames):\\n for gen in range(num_generations):\\n\\n if Trainer.VERBOSE:\\n print(\\\"Generation:\\\", gen)\\n\\n # Generate new root Teams\\n self.generation()\\n\\n # Evaluate current agents\\n self.evaluation(env, num_episodes, num_frames)\\n\\n # Perform selection\\n self.selection()\\n\\n # Return to top-performing agent. Typically not used, but nice to have\\n ranked_agents = sorted(self.agent_pop, key=lambda rt : rt.team.fitness, reverse=True)\\n return ranked_agents[0]\",\n \"def train(self, env):\\n\\n\\t\\tmin_average_reward_for_stopping = 195\\n\\t\\tconsecutive_successful_episodes_to_stop = 10\\n\\t\\tlast_10_rewards = deque(maxlen=consecutive_successful_episodes_to_stop)\\n\\n\\t\\tnum_Episodes = []\\n\\t\\tEpisode_Rewards = []\\n\\n\\t\\tfor episode in range(self.episodes):\\n\\t\\t\\tstate = env.reset()\\n\\t\\t\\tstate = np.reshape(state, [1, self.state_size])\\n\\t\\t\\tdone = False\\n\\t\\t\\ttotal_reward = 0\\n\\n\\t\\t\\twhile not done:\\n\\t\\t\\t\\taction = self.act(state)\\n\\t\\t\\t\\tnext_state, reward, done, _ = env.step(action)\\n\\t\\t\\t\\tnext_state = np.reshape(next_state, [1, self.state_size])\\n\\t\\t\\t\\tself.remember(state, action, reward, next_state, done)\\n\\t\\t\\t\\tstate = next_state\\n\\t\\t\\t\\ttotal_reward += reward\\n\\n\\t\\t\\tnum_Episodes.append(episode)\\n\\t\\t\\tEpisode_Rewards.append(total_reward)\\n\\t\\t\\tlast_10_rewards.append(total_reward)\\n\\t\\t\\tlast_10_avg_reward = np.mean(last_10_rewards)\\n\\t\\t\\tprint(episode, last_10_avg_reward)\\n\\n\\t\\t\\t# call experience relay\\n\\t\\t\\tif len(self.memory) >= self.batch_size:\\n\\t\\t\\t\\tself.replay(self.batch_size)\\n\\t\\t\\t# Stopping criteria\\n\\t\\t\\tif len(\\n\\t\\t\\t\\t\\tlast_10_rewards) == consecutive_successful_episodes_to_stop \\\\\\n\\t\\t\\t\\t\\tand last_10_avg_reward > min_average_reward_for_stopping:\\n\\t\\t\\t\\tprint(\\\"Solved after {} epsiodes\\\".format(episode))\\n\\t\\t\\t\\tbreak\",\n \"def get_traj(agent, env, episode_max_length):\\n # MARK: changed\\n\\n env.reset()\\n obs = []\\n acts = []\\n rews = []\\n entropy = []\\n info = []\\n machines = []\\n ob = env.observe()\\n\\n for _ in range(episode_max_length):\\n\\n act_prob = agent.get_action(ob)\\n machine_prob = agent.get_machine(ob)\\n # csprob_n = np.cumsum(act_prob)\\n # a = (csprob_n > np.random.rand()).argmax()\\n # print(act_prob)\\n ob = ob.reshape(ob.shape[0]*ob.shape[1])\\n obs.append(ob) # store the ob at current decision making step\\n acts.append(act_prob)\\n machines.append(machine_prob)\\n ob, rew, done, info = env.step(act_prob,machine_prob, repeat=True)\\n\\n rews.append(rew)\\n\\n entropy.append(get_entropy(act_prob))\\n if done: break\\n return {'reward': np.array(rews),\\n 'ob': np.array(obs),\\n 'action': np.array(acts),\\n 'entropy': entropy,\\n 'info': info,\\n 'machine':np.array(machines)\\n }\",\n \"def run_episode(self):\\n self.reset_episode()\\n obs = self.env.reset()\\n while True:\\n action = self.Policy[self.env.stateDict[obs]]\\n new_obs, reward, done, _ = self.env.step(action)\\n if self.mode=='debug':\\n print(\\\"PrevObs:{}, Action:{}, Obs:{}, Reward:{}, Done:{}\\\"\\n .format(obs, action, new_obs,reward,done))\\n self.totalReward += reward\\n self.totalSteps += 1\\n if done:\\n break\\n else:\\n obs = new_obs\\n return self.totalReward\",\n \"def doEpisodes(self, number = 1):\\n all_rewards = []\\n for dummy in range(number):\\n self.agent.newEpisode()\\n rewards = []\\n self.stepid = 0\\n self.task.reset()\\n while not self.task.isFinished():\\n r = self._oneInteraction()\\n rewards.append(r)\\n all_rewards.append(rewards)\\n return all_rewards\",\n \"def collect_episode(env, policy, buffer, render_option):\\n state = env.reset()\\n done = False\\n while not done:\\n if render_option == 'collect':\\n env.render()\\n action = policy(state)\\n next_state, reward, done, _ = env.step(action)\\n if done:\\n reward = -1.0\\n buffer.record(state, reward, next_state, action, done)\\n state = next_state\",\n \"def scraping_episodes(self, serie_data, episodes_list):\\n episodes_data = []\\n for episode in episodes_list:\\n # Se arma este dict para localizar los campos\\n # en el json y que sea mas facil procesarlos mas adelante\\n epi_details = episode[0]['body']['details']\\n epi_dict = {\\n 'ParentId': serie_data.id,\\n 'ParentTitle': serie_data.clean_title,\\n 'Id': episode[0]['id'],\\n 'Title': epi_details['title'],\\n 'Type': 'episode',\\n 'JSON': {\\n 'Synopsis': epi_details['description'],\\n 'Metadata': epi_details['metadata'].replace('\\\\xa0', ''),\\n 'Rating': epi_details['localizedRating']['value'],\\n 'Image': epi_details,\\n 'Groups': episode[1]['body']['groups'],\\n 'SeasonAndNumber': episode[2]['body']['metadata'],\\n 'isFree': episode[0]['body']['isFree']\\n }\\n }\\n payload_epi = self.build_payload(epi_dict)\\n # Si la serie es original sus episodios también\\n payload_epi.is_original = serie_data.is_original\\n episodes_data.append(payload_epi)\\n payload_epi = payload_epi.payload_episode()\\n Datamanager._checkDBandAppend(\\n self, payload_epi, self.scraped_epi, self.payloads_epi,\\n isEpi=True\\n )\\n return episodes_data\",\n \"def explore(self, episode_count):\\n # single agent, always use the `run_one_episode` api.\\n # multi agent with `standalone` api_type, use the `run_one_episode` api.\\n if self.env_info[\\\"api_type\\\"] == \\\"standalone\\\":\\n # (use_explore, collect)\\n _paras = [\\n (True, False if _ag.alg.async_flag else True) for _ag in self.agents\\n ]\\n job_funcs = [agent.run_one_episode for agent in self.agents]\\n for _epi_index in range(episode_count):\\n _start2 = time()\\n self.env.reset()\\n for agent in self.agents:\\n agent.reset()\\n\\n trajectory_list = self.bot.do_multi_job(job_funcs, _paras)\\n for agent, trajectory in zip(self.agents, trajectory_list):\\n if not agent.alg.async_flag:\\n # self.trajectories.append(trajectory)\\n self.send_explorer.send(trajectory)\\n\\n self._post_processes()\\n self.ag_stats.explore_time_in_epi = time() - _start2\\n\\n if _epi_index == episode_count - 1:\\n self.ag_stats.update_with_agent_stats(\\n [agent.get_perf_stats() for agent in self.agents]\\n )\\n\\n elif self.env_info[\\\"api_type\\\"] == \\\"unified\\\":\\n for _ in range(episode_count):\\n _start2 = time()\\n trajectories = self._run_one_unified_episode(\\n use_explore=True, collect=True)\\n\\n for _ag, trajectory in zip(self.agents, trajectories):\\n if not _ag.alg.async_flag:\\n # self.trajectories.append(trajectory)\\n self.send_explorer.send(trajectory)\\n\\n self._post_processes()\\n self.ag_stats.explore_time_in_epi = time() - _start2\\n else:\\n pass\\n\\n self.clear_trajectories()\\n return self.ag_stats.get()\",\n \"def generate_episode(env, policy, max_steps=500):\\n episode = []\\n curr_state = env.reset() # reset the environment and place the agent in the start square\\n ############################\\n # YOUR IMPLEMENTATION HERE #\\n \\n finished = False\\n steps = 0\\n \\n while not finished and steps < max_steps: # Continue generating episode until finished or max_steps\\n # while steps < max_steps:\\n action, reward, new_state, finished = take_one_step(env, policy, curr_state) # take a new action in the current state, get new state\\n episode.append((curr_state, action, reward))\\n curr_state = new_state\\n steps += 1\\n ############################\\n \\n return episode\",\n \"def on_episode_end(self, episode, logs):\\n duration = timeit.default_timer() - self.episode_start[episode]\\n episode_steps = len(self.observations[episode])\\n\\n # Format all metrics.\\n metrics = np.array(self.metrics[episode])\\n metrics_template = ''\\n metrics_variables = []\\n with warnings.catch_warnings():\\n warnings.filterwarnings('error')\\n for idx, name in enumerate(self.metrics_names):\\n if idx > 0:\\n metrics_template += ', '\\n try:\\n value = np.nanmean(metrics[:, idx])\\n metrics_template += '{}: {:f}'\\n except Warning:\\n value = '--'\\n metrics_template += '{}: {}'\\n metrics_variables += [name, value]\\n metrics_text = metrics_template.format(*metrics_variables)\\n\\n nb_step_digits = str(int(np.ceil(np.log10(self.params['nb_steps']))) + 1)\\n # template = '{step: nb_step_digits}/{nb_steps}: episode: {episode}, duration: {duration:.3f}s, episode steps: {episode_steps}, steps per second: {sps:.0f}, episode reward: {episode_reward:.3f}, mean reward: {reward_mean:.3f} [{reward_min:.3f}, {reward_max:.3f}], mean action: {action_mean:.3f} [{action_min:.3f}, {action_max:.3f}], mean observation: {obs_mean:.3f} [{obs_min:.3f}, {obs_max:.3f}], {metrics}'\\n template = '(( episode: {episode}, step: {steps}/{nb_steps}, episode_steps: {episode_steps} --- target_reached: {target_reached}, target_reached_in_steps: {target_reached_in_steps} --- episode_reward: {episode_reward:.3f}, mean_reward: {reward_mean:.3f} --- metrics: {metrics} ))'\\n variables = {\\n # 'step': self.step,\\n 'nb_steps': self.params['nb_steps'],\\n 'episode': episode + 1,\\n # 'duration': duration,\\n 'episode_steps': episode_steps,\\n # 'sps': float(episode_steps) / duration,\\n # 'episode_reward_sum': np.sum(self.rewards[episode]),\\n 'reward_mean': np.mean(self.rewards[episode]),\\n # 'reward_min': np.min(self.rewards[episode]),\\n # 'reward_max': np.max(self.rewards[episode]),\\n # 'action_mean': np.mean(self.actions[episode]),\\n # 'action_min': np.min(self.actions[episode]),\\n # 'action_max': np.max(self.actions[episode]),\\n # 'obs_mean': np.mean(self.observations[episode]),\\n # 'obs_min': np.min(self.observations[episode]),\\n # 'obs_max': np.max(self.observations[episode]),\\n 'steps': logs['steps'],\\n 'target_reached': logs['target_reached'],\\n 'target_reached_in_steps': logs['target_reached_in_steps'],\\n 'episode_reward': logs['episode_reward'],\\n 'metrics': metrics_text,\\n }\\n print(template.format(**variables))\\n\\n # Free up resources.\\n del self.episode_start[episode]\\n del self.observations[episode]\\n del self.rewards[episode]\\n del self.actions[episode]\\n del self.metrics[episode]\",\n \"def _flat_data_to_episodes(self, flat_data):\\n data = []\\n episode_start = 0\\n for t in range(len(flat_data['observations'])):\\n if flat_data['terminals'][t]:\\n episode = {k: v[episode_start:t + 1] for k, v in flat_data.items()}\\n data.append(episode)\\n episode_start = t + 1\\n return data\",\n \"def train(n_episodes=1000, max_n_steps=300, eps_start=1.0, eps_end=0.01, eps_decay=0.995, strCheckpointFile='checkpoint.pth'):\\n\\n global env\\n scores = [] # list containing scores from each episode\\n scores_window = deque(maxlen=100) # last 100 scores\\n eps = eps_start # initialize epsilon\\n num_saves = 0\\n for i_episode in range(1, n_episodes + 1):\\n env_info = env.reset(train_mode=True)[brain_name] # reset the environment\\n state = env_info.vector_observations[0] # get the current state\\n score = 0 # initialize the score\\n last_t = max_n_steps\\n for t in range(max_n_steps):\\n action = agent.act(state, eps) # agent returns an epsilon-greedy action based on state\\n env_info = env.step(action)[brain_name] # send the action to the environment\\n next_state = env_info.vector_observations[0] # get the next state\\n reward = env_info.rewards[0] # get the reward\\n done = env_info.local_done[0] # see if episode has finished\\n agent.step(state, action, reward, next_state, done) # records experience and learns (depending on settings)\\n state = next_state\\n score += reward\\n if done:\\n last_t = t + 1\\n break\\n scores_window.append(score) # save most recent score\\n scores.append(score) # save most recent score\\n eps = max(eps_end, eps_decay * eps) # decrease epsilon\\n print('\\\\rEpisode {}\\\\tNum steps: {}\\\\tAverage Score: {:.2f}'.format(i_episode, last_t, np.mean(scores_window)))\\n # if i_episode % 100 == 0:\\n # print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\\n if np.mean(scores_window) >= 13: # win condition in course\\n if num_saves == 0:\\n print('\\\\nEnvironment solved in {:d} episodes!\\\\tAverage Score: {:.2f}'.format(i_episode - 100, np.mean(scores_window)))\\n print('\\\\nTraining will continue and the checkpoint will be overwritten every 100 episodes')\\n print('\\\\nSaving a checkpoint now, you may interrupt code execution with eg Ctrl+C')\\n torch.save(agent.qnetwork_local.state_dict(), strCheckpointFile)\\n else:\\n if i_episode % 100 == 0:\\n print('\\\\nSaving another checkpoint now, you may interrupt code execution with eg Ctrl+C')\\n torch.save(agent.qnetwork_local.state_dict(), strCheckpointFile)\\n num_saves += 1\\n\\n env.close()\\n\\n # plot the scores\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n plt.plot(np.arange(len(scores)), scores)\\n plt.ylabel('Score')\\n plt.xlabel('Episode #')\\n # plt.show()\\n plt.savefig('training_score_by_episode.png')\\n return scores\",\n \"def train_dqn(self, n_episodes=2000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\\n self.scores = [] # list containing scores from each episode\\n scores_window = deque(maxlen=100) # last 100 scores\\n eps = eps_start # initialize epsilon\\n for i_episode in range(1, n_episodes+1):\\n env_info = self.env.reset(train_mode=True)[self.brain_name] # reset the environment\\n state = env_info.vector_observations[0] # get the current state\\n score = 0 # initialize the score\\n for t in range(max_t):\\n action = self.agent.act(state, eps)\\n env_info = self.env.step(action)[self.brain_name] # send the action to the environment\\n next_state = env_info.vector_observations[0] # get the next state\\n reward = env_info.rewards[0] # get the reward\\n done = env_info.local_done[0] # see if episode has finished\\n self.agent.step(state, action, reward, next_state, done)\\n state = next_state\\n score += reward\\n if done:\\n break \\n scores_window.append(score) # save most recent score\\n self.scores.append(score) # save most recent score\\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\\\"\\\")\\n if i_episode % 100 == 0:\\n print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\\n # we use 15.0 just to be sure\\n if np.mean(scores_window)>=self.threshold:\\n print('\\\\nEnvironment solved in {:d} episodes!\\\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\\n break\\n return self.scores\",\n \"def get_episode_list(self):\\n if self.episodes is not None:\\n return self.episodes\\n\\n self.episodes = []\\n\\n # Now before we return pre-emptively fetch the episode list.\\n # XXX We _could_ put this in a 'get_episode_list' method that does the\\n # fetching then.. but for now we are just going to have it done\\n # here.\\n #\\n if len(self.episode_guide_urls) == 0:\\n return self.episodes\\n\\n for url in self.episode_guide_urls:\\n url_data = url.get()\\n\\n # Now we run the GetEpisodeList rules on this data that\\n # we just retrieved.\\n #\\n self.scraper.parser.set_buffer(1, url_data)\\n self.scraper.parser.set_buffer(2, url.url)\\n\\n # This gets us a XML string with the list of episodes in it.\\n # parse this in to a dom and then go through each <episode>\\n # element creating an Episode object to append to our episode\\n # list\\n ep_list_result = self.scraper.parser.parse(FN_GET_EPISODE_LIST,\\n self.scraper.settings)\\n dom = parseString(ep_list_result)\\n eps = dom.firstChild\\n ep = first_child(eps, \\\"episode\\\")\\n while ep:\\n self.episodes.append(Episode(ep, self, self.scraper))\\n ep = next_sibling(ep, \\\"episode\\\")\\n dom.unlink()\\n dom = None\\n \\n return self.episodes\",\n \"def stopEpisode(self):\\n if self.episodesSoFar < self.numTraining:\\n self.accumTrainRewards += self.episodeRewards\\n else:\\n self.accumTestRewards += self.episodeRewards\\n self.episodesSoFar += 1\\n if self.episodesSoFar >= self.numTraining:\\n # Take off the training wheels\\n self.epsilon = 0.0 # no exploration\\n self.alpha = 0.0 # no learning\",\n \"def train(self):\\n tic = time.time()\\n means = []\\n stds = []\\n steps = 0\\n scores_window = deque(maxlen=100)\\n for e in range(1,self.episodes):\\n\\n self.noise.step()\\n episode_scores = []\\n obs = self.env.reset()\\n for t in range(self.tmax):\\n actions = self.act(obs)\\n next_obs,rewards,dones = self.env.step(actions)\\n\\n # Store experience\\n if np.max(rewards) > 0:\\n print('hit the ball over the net',rewards)\\n self.R.add(obs.reshape(1,48),obs,actions,rewards,next_obs.reshape(1,48),next_obs,dones)\\n obs = next_obs\\n # Score tracking\\n episode_scores.append(np.max(rewards))\\n \\n # Learn\\n if len(self.R) > self.min_buffer_size:\\n for _ in range(self.SGD_epoch):\\n # Update each agent\\n for i in range(self.num_agents):\\n self.learn(i)\\n # update target networks\\n self.update_targets_all()\\n \\n steps += int(t)\\n means.append(np.mean(episode_scores))\\n stds.append(np.std(episode_scores))\\n scores_window.append(np.sum(episode_scores))\\n if e % 4 == 0:\\n toc = time.time()\\n r_mean = np.mean(scores_window)\\n r_max = max(scores_window)\\n r_min = min(scores_window)\\n r_std = np.std(scores_window)\\n plot(self.name,means,stds)\\n print(\\\"\\\\rEpisode: {} out of {}, Steps {}, Rewards: mean {:.2f}, min {:.2f}, max {:.2f}, std {:.2f}, Elapsed {:.2f}\\\".format(e,self.episodes,steps,r_mean,r_min,r_max,r_std,(toc-tic)/60))\\n if np.mean(scores_window) > self.winning_condition:\\n print('Env solved!')\\n # save scores\\n pickle.dump([means,stds], open(str(self.name)+'_scores.p', 'wb'))\\n # save policy\\n self.save_weights(self.critic_path,self.actor_path)\\n break\",\n \"def run_episode(self):\\n # Reset environment\\n self.agent.env.reset()\\n done = False\\n step_count = 0\\n total_reward = 0\\n\\n while not done:\\n reward, done = self.agent.explore()\\n step_count += 1\\n if step_count % 100 == 0:\\n print('step count {}'.format(step_count))\\n total_reward += self.agent.params['gamma']**step_count * reward\\n return step_count, total_reward\",\n \"def terminal_test(self):\\n\\n for self.cur_ep in tqdm.tqdm(range(1, self.episodes + 1), ascii=True, unit='episodes'):\\n\\n # Nombre de passages dans la boucle principale\\n step = 1\\n\\n cur_state = self.env.reset()\\n\\n done = False\\n\\n while not done:\\n\\n # Choix au hasard entre :\\n if np.random.random() > self.epsilon:\\n # Action à partir de la q-table\\n action = np.argmax(self.agent.get_q_values(np.array(cur_state)))\\n\\n else:\\n # Action random\\n action = np.random.randint(0, self.env.ACTION_SPACE_SIZE)\\n\\n # On effectue une action avec le serpent\\n new_state, reward, done = self.env.step(action)\\n\\n # Ajout d'un exemple dans la mémoire\\n self.agent.update_training_set((cur_state, action, reward, new_state, done))\\n\\n # Entrainement éventuel\\n self.agent.train()\\n\\n cur_state = new_state\\n step += 1\\n\\n if self.epsilon > self.MIN_EPSILON:\\n self.epsilon *= self.EPSILON_DECAY\\n self.epsilon = max(self.MIN_EPSILON, self.epsilon)\\n\\n if self.save_model:\\n self.agent.save_model(self.model_file_name)\",\n \"def stopEpisode(self):\\n if self.episodesSoFar < self.numTraining:\\n self.accumTrainRewards += self.episodeRewards\\n else:\\n self.accumTestRewards += self.episodeRewards\\n self.episodesSoFar += 1\\n if self.episodesSoFar >= self.numTraining:\\n # Take off the training wheels\\n self.epsilon = 1.0 # no exploration\\n self.lr = 0.0 # no learning\",\n \"def train_multiple_eps(self, env, no_episodes=200, horizon=1000, lr=0.1):\\n\\n\\t\\tr_vec = []\\n\\t\\tep_len_vec = []\\n\\t\\tfor i in range(no_episodes):\\n\\n\\t\\t\\t# Run the agent for one episode and get a vector of rewards and a scalar for episode length\\n\\t\\t\\tr_ep, ep_len = self.train_one_eps(env, horizon=horizon, lr=lr)\\n\\n\\t\\t\\t# Storing the information\\n\\t\\t\\tr_vec.append(r_ep)\\n\\t\\t\\tep_len_vec.append(ep_len)\\n\\n\\t\\treturn r_vec, ep_len_vec\",\n \"def test():\\n env = gym.make('CartPole-v1')\\n\\n results = []\\n for _ in range(100):\\n results.append(episode(env, render=False, verbose=False))\\n\\n print(f'average={sum(results) / len(results)} '\\n f'max={max(results)} '\\n f'min={min(results)}')\",\n \"def episode_terminated(self):\\n # Increase the number of episodes\\n self.episode_count += 1\\n self.representation.episode_terminated()\\n # Set eligibility Traces to zero if it is end of the episode\\n if self.eligibility_trace is not None:\\n self.eligibility_trace = np.zeros_like(self.eligibility_trace)\",\n \"def save_episode_models(self, episode):\\n s1 = './' + self.game_name + '/'\\n s_pth = '{}.pth'.format(episode + 1)\\n torch.save(self.actor.state_dict(), s1 + 'actor' + s_pth)\\n torch.save(self.critic1.state_dict(), s1 + 'critic1_' + s_pth)\\n torch.save(self.critic2.state_dict(), s1 + 'critic2_' + s_pth)\\n torch.save(self.critic1_target.state_dict(), s1 + 'critic1_target' + s_pth)\\n torch.save(self.critic2_target.state_dict(), s1 + 'critic2_target' + s_pth)\\n\\n torch.save(self.log_alpha, s1 + 'log_alpha' + s_pth)\\n\\n torch.save(self.actor_optimiser.state_dict(), s1 + 'actor_optimizer' + s_pth)\\n torch.save(self.critic1_optimiser.state_dict(), s1 + 'critic1_optimizer' + s_pth)\\n torch.save(self.critic2_optimiser.state_dict(), s1 + 'critic2_optimizer' + s_pth)\\n torch.save(self.alpha_optimiser.state_dict(), s1 + 'alpha_optimizer' + s_pth)\\n np.save(s1 + 'scores{}.npy'.format(episode + 1), self.scores)\",\n \"def learn(self):\\n\\n for i in range(1, self.args.numIters + 1):\\n print('------ ITER ' + str(i) + '------')\\n iterationTrainExamples = deque([], maxlen=self.args.maxlenOfQueue)\\n\\n for eps in range(self.args.numEps):\\n print('------ Self Play Episode ' + str(eps) + '------')\\n self.mcts = TSPMCTS(self.args, self.game, self.nnet) # reset search tree\\n iterationTrainExamples += self.executeEpisode()\\n\\n # save the iteration examples to the history\\n self.trainExamplesHistory.append(iterationTrainExamples)\\n\\n if len(self.trainExamplesHistory) > self.args.numItersForTrainExamplesHistory:\\n self.trainExamplesHistory.pop(0)\\n\\n # shuffle examples before training\\n trainExamples = []\\n for e in self.trainExamplesHistory:\\n trainExamples.extend(e)\\n\\n # training new network\\n if self.args.numEps > 0:\\n self.nnet.train(trainExamples)\\n nmcts = TSPMCTS(self.args, self.game, self.nnet)\\n\\n print('PLAYING GAMES')\\n if self.args.arenaCompare:\\n arena = SinglePlayerArena(lambda x: np.argmax(nmcts.getActionProb(x, temp=0)), self.game)\\n wins, losses = arena.playSinglePlayerGames(self.args.arenaCompare)\\n print('WINS/LOSSES: %d / %d' % (wins, losses))\",\n \"def run_episode(self, mode=0, eps=0.):\\n if mode==0:\\n eps = 0.\\n done = False\\n score = 0 \\n \\n while not done:\\n state = self.env_info.vector_observations[0] # get the current state\\n action = self.agent.act(state, eps=eps) # get an action using epsilon greedy policy\\n self.env_info = self.env.step(action)[self.brain_name] # send the action to the environment\\n next_state = self.env_info.vector_observations[0] # get the next state\\n reward = self.env_info.rewards[0] # get the reward\\n done = self.env_info.local_done[0] # see if episode has finished\\n \\n if mode == 1:\\n self.agent.step(state, action, reward, next_state, done)\\n \\n score += reward\\n \\n self.reset_env() # reset the environment\\n \\n return score\",\n \"def run_episode(env, gamma = 1.0, render = False):\\n actions = 4\\n obs = env.reset()\\n total_reward = 0\\n step_idx = 0\\n\\n while True:\\n if render:\\n env.render()\\n obs, reward, done , _ = env.step(random.randint(0, actions - 1))\\n x1, x2, x3, x4, x5, x6, x7, x8 = obs\\n x1s.append(x1)\\n x2s.append(x2)\\n x3s.append(x3)\\n x4s.append(x4)\\n x5s.append(x5)\\n x6s.append(x6)\\n x7s.append(x7)\\n x8s.append(x8)\\n total_reward += (gamma ** step_idx * reward)\\n step_idx += 1\\n if done:\\n break\\n return total_reward, step_idx\",\n \"def n_episodes(self):\\n raise NotImplementedError\",\n \"def store_episode(self):\\n episode_buffer = self._convert_episode_to_batch_major()\\n episode_batch_size = len(episode_buffer['observation'])\\n idx = self._get_storage_idx(episode_batch_size)\\n\\n for key in self._buffer:\\n self._buffer[key][idx] = episode_buffer[key]\\n self._n_transitions_stored = min(\\n self._size_in_transitions, self._n_transitions_stored +\\n self._time_horizon * episode_batch_size)\",\n \"def episode_step(self):\\n self.nsteps += 1\",\n \"def execute_and_get_episodes(self, num_episodes, max_timesteps_per_episode=0, deterministic=False):\\n pass\",\n \"def train(self, num_episodes=10000):\\n\\n self.game.restart()\\n\\n self.exp_states = defaultdict(int)\\n\\n for i in tqdm(range(num_episodes)):\\n\\n self.game.deal_cards()\\n\\n possible_actions = self.game.get_actions()\\n\\n player_state = self.game.get_player_state()\\n player_action = self.player.get_action(player_state,\\n possible_actions,\\n explore_exploit='explore')\\n\\n # Bookkeep visited states (?)\\n player_state_str = np.array2string(player_state)\\n self.exp_states[player_state_str] += 1\\n\\n opponent_state = self.game.get_opponent_state()\\n opponent_action = self.opponent.get_action(opponent_state,\\n possible_actions)\\n\\n self.game.set_player_action(player_action)\\\\\\n .set_opponent_action(opponent_action)\\n\\n player_score, opponent_score = self.game.get_scores()\\n\\n reward = self._get_reward(player_score, opponent_score)\\n self.player.learn(player_state,\\n player_action,\\n reward)\\n self.player.learn(opponent_state,\\n opponent_action,\\n -reward)\\n \\n print(\\\"Training done!\\\")\",\n \"def collect_selfplay_data(self):\\n winner, play_data = self.game.start_self_play(self.mcts_player,\\n temp=self.temp)\\n play_data = list(play_data)[:]\\n episode_len = len(play_data)\\n # augment the data\\n play_data = self.get_equi_data(play_data)\\n self.data_buffer.extend(play_data)\\n return episode_len\",\n \"def Worker(episode):\\n episode_start_time = time.monotonic()\\n\\n stop = 0\\n near_boundaries = 0\\n failed = 0\\n\\n cdf_t = -1.0 * np.ones(LEN_CDF_T)\\n cdf_h = -1.0 * np.ones(LEN_CDF_H)\\n bin_t = 0\\n bin_h = 0\\n cdf_t[bin_t] = 0.0\\n cdf_h[bin_h] = 0.0\\n\\n myenv, mypol = init_envs()\\n check_envs(myenv, mypol)\\n\\n t = 0 # time step\\n cumulative_hits = 0 # cumulative number of hits (int)\\n T_mean = 0\\n p_not_found_yet = 1\\n\\n while True:\\n\\n # choice of action\\n action = mypol.choose_action()\\n\\n # step in myenv\\n hit, p_end, done = myenv.step(action, quiet=(mypol.policy_index == -1))\\n near_boundaries = max(near_boundaries, myenv.agent_near_boundaries)\\n\\n t += 1\\n T_mean += p_not_found_yet\\n\\n p_found = 1.0 - p_not_found_yet * (1.0 - p_end)\\n\\n bin_to = bin_t\\n bin_t = int((t - BIN_START_T) // BIN_SIZE_T)\\n cdf_t[bin_to:bin_t] = cdf_t[bin_to]\\n cdf_t[bin_t] = p_found\\n\\n bin_ho = bin_h\\n bin_h = int((cumulative_hits - BIN_START_H) // BIN_SIZE_H)\\n cdf_h[bin_ho:bin_h] = cdf_h[bin_ho]\\n cdf_h[bin_h] = p_found\\n\\n p_not_found_yet *= 1 - p_end\\n cumulative_hits += hit\\n\\n if p_not_found_yet < STOP_p or p_end > 1 - EPSILON or done:\\n stop = 1\\n elif t > STOP_t - 1:\\n stop = 2\\n failed = 1\\n elif myenv.agent_stuck:\\n stop = 3\\n failed = 1\\n\\n if stop:\\n if episode % 100 == 0 and sys.stdout.isatty() and not WITH_MPI:\\n txt = \\\"episode: %7d [hit(t0) = %d] || <nsteps>: %7.2f || total nb of steps: %d\\\" \\\\\\n % (episode, myenv.initial_hit, T_mean, t)\\n if stop == 1:\\n print(txt)\\n elif stop == 2:\\n print(txt + \\\" || max iter reached! (prob not found yet = %7.2e)\\\" % p_not_found_yet)\\n elif stop == 3:\\n print(txt + \\\" || agent stuck! (prob not found yet = %7.2e)\\\" % p_not_found_yet)\\n\\n sys.stdout.flush()\\n break\\n\\n # fill in remaining bins\\n cdf_t[bin_t + 1:LEN_CDF_T] = cdf_t[bin_t]\\n cdf_h[bin_h + 1:LEN_CDF_H] = cdf_h[bin_h]\\n\\n if np.any(cdf_t < 0) or np.any(cdf_h < 0):\\n raise Exception(\\\"Missing values in the cdf, check implementation\\\")\\n\\n # monitoring\\n episode_elapsed_time = time.monotonic() - episode_start_time\\n monitoring_episode_tmp_file = os.path.join(DIR_TMP, str(\\\"monitoring_episode_\\\" + str(episode) + \\\".txt\\\"))\\n with open(monitoring_episode_tmp_file, \\\"a\\\") as mfile:\\n mfile.write(\\\"%9d\\\\t%8d\\\\t%9d\\\\t%13d\\\\t%11.2e\\\\t%15.4e\\\\t%21.4e\\\\n\\\" % (\\n episode, myenv.initial_hit, stop, near_boundaries, p_not_found_yet, T_mean, episode_elapsed_time))\\n\\n return cdf_t, cdf_h, T_mean, failed\",\n \"def _sample_episode(self):\\n\\n Knovel = random.sample(self.labelIds, self.nKnovel)\\n #print(Knovel)\\n #exit(0)\\n nKnovel = len(Knovel)\\n assert((self.nTestNovel % nKnovel) == 0)\\n nEvalExamplesPerClass = int(self.nTestNovel / nKnovel)\\n #print(nEvalExamplesPerClass)\\n #exit(0)\\n Tnovel = []\\n Exemplars = []\\n for Knovel_idx in range(len(Knovel)):\\n ids = (nEvalExamplesPerClass + self.nExemplars)\\n img_ids = random.sample(self.labels2inds[Knovel[Knovel_idx]], ids) \\n\\n imgs_tnovel = img_ids[:nEvalExamplesPerClass]\\n imgs_emeplars = img_ids[nEvalExamplesPerClass:]\\n #print(imgs_tnovel)\\n #exit(0)\\n Tnovel += [(img_id, Knovel_idx) for img_id in imgs_tnovel]\\n Exemplars += [(img_id, Knovel_idx) for img_id in imgs_emeplars]\\n assert(len(Tnovel) == self.nTestNovel)\\n assert(len(Exemplars) == nKnovel * self.nExemplars)\\n random.shuffle(Exemplars)\\n random.shuffle(Tnovel)\\n\\n return Tnovel, Exemplars\",\n \"def finish_episode(tribes, learners, optimizers, gamma, cuda): \\n \\n num_learners = len(learners)\\n total_norms = [0 for i in range(num_learners)]\\n policy_losses = [[] for i in range(num_learners)]\\n losses = [[] for i in range(num_learners)]\\n T_reward = []\\n\\n \\n for i in range(num_learners):\\n\\n R = 0\\n saved_actions = learners[i].saved_actions\\n \\n for t in tribes:\\n if t.name is learners[i].tribe:\\n \\n # Based on team culture, calculate the team reward for the agent \\n culture = t.culture['name']\\n \\n if culture is 'cooperative':\\n T_reward = t.tribal_awards()\\n elif culture is 'individualist':\\n T_reward = t.tribal_awards()\\n elif culture is 'no_fragging':\\n T_reward = t.tribal_awards(US_hits = learners[i].US_hits)\\n elif culture is 'pacifist':\\n T_reward = t.tribal_awards(tag_hist = learners[i].tag_hist)\\n elif culture is 'pacifist_exile':\\n T_reward = t.tribal_awards(tag_hist = learners[i].tag_hist, \\\\\\n in_banned_hist=learners[i].in_banned_hist)\\n elif culture is 'pacifist_follower':\\n T_reward = t.tribal_awards(tag_hist = learners[i].tag_hist, \\\\\\n in_target_hist=learners[i].in_target_hist)\\n elif culture is 'warlike':\\n T_reward = t.tribal_awards(US_hits = learners[i].US_hits,THEM_hits = learners[i].THEM_hits)\\n else:\\n T_reward = t.tribal_awards()\\n \\n # For debug only\\n # print('Agent{} receives tribal award from Tribe{}'.format(i,t.name))\\n # print (T_reward)\\n # print (learners[i].rewards)\\n \\n # Do not implement actor-critic for now\\n # value_losses = []\\n \\n rewards = deque()\\n\\n for r,T in zip(learners[i].rewards[::-1],T_reward[::-1]):\\n # The agent is incentivized to cooperate by an award of 30% of what the tribe takes\\n # in by all its members\\n R = r + T + gamma * R\\n rewards.appendleft(R)\\n \\n rewards = list(rewards)\\n rewards = torch.Tensor(rewards)\\n if cuda:\\n rewards = rewards.cuda()\\n\\n # z-score rewards\\n rewards = (rewards - rewards.mean()) / (1.1e-7+rewards.std())\\n \\n #Debug \\n #print (rewards) \\n \\n \\\"\\\"\\\"\\n Do not implement actor-critic for now!!!\\n for (log_prob, state_value), r in zip(saved_actions, rewards):\\n reward = r - state_value.data[0]\\n policy_losses.append(-log_prob * Variable(reward))\\n r = torch.Tensor([r])\\n if cuda:\\n r = r.cuda()\\n value_losses.append(torch.nn.functional.smooth_l1_loss(state_value,\\n Variable(r)))\\n\\n optimizer.zero_grad()\\n loss = torch.stack(policy_losses).sum() + torch.stack(value_losses).sum()\\n loss.backward() \\n \\n \\n \\\"\\\"\\\"\\n for log_prob, r in zip(saved_actions, rewards):\\n r = torch.Tensor([r])\\n if cuda:\\n r = r.cuda()\\n policy_losses[i].append(-log_prob * Variable(r))\\n\\n optimizers[i].zero_grad()\\n losses[i] = torch.stack(policy_losses[i]).sum()\\n losses[i].backward()\\n \\n # Gradient Clipping Update: prevent exploding gradient\\n total_norms[i] = torch.nn.utils.clip_grad_norm_(learners[i].parameters(), 8000)\\n \\n optimizers[i].step()\\n learners[i].clear_history() # clear an agent's history at the end of episode\\n\\n\\n return total_norms\",\n \"def train(env, agent, n_episodes:int=1000, max_t:int=1000, eps_start:float=1.0, eps_end:float=0.01, eps_decay:float=0.995, score_threshold:float=13)->list:\\n scores = []\\n scores_window:Deque[float] = deque(maxlen=100)\\n eps = eps_start\\n best_score = float(\\\"-inf\\\")\\n writer = tensorboard.SummaryWriter(f\\\"runs/{int(time())}\\\")\\n for i_episode in range(1, n_episodes+1):\\n state = env.reset()\\n score = 0\\n writer.add_scalar(\\\"train/epsilon\\\", eps, i_episode)\\n \\n start = time()\\n for t in range(max_t):\\n action = agent.act(state, eps)\\n next_state, reward, done, _ = env.step(action)\\n # writer.add_scalar(\\\"reward\\\", reward, (i_episode - 1) * max_t + t)\\n agent.step(state, action, reward, next_state, done)\\n state = next_state\\n score += reward\\n if done:\\n break\\n\\n time_for_episode = time() - start\\n writer.add_scalar(\\\"train/time\\\", time_for_episode, i_episode)\\n scores_window.append(score)\\n scores.append(score)\\n\\n eps = max(eps_end, eps_decay*eps)\\n window_score = np.mean(scores_window)\\n\\n writer.add_scalar(\\\"train/reward\\\", score, i_episode) \\n writer.add_scalar(\\\"train/window\\\", window_score, i_episode)\\n writer.add_scalar(\\\"train/memory_size\\\", len(agent.memory), i_episode)\\n\\n probs = getattr(agent.memory, 'probs', None)\\n if probs is not None:\\n writer.add_histogram(\\\"train/memory_probs\\\", probs, i_episode)\\n\\n beta = getattr(agent.memory, 'beta', None)\\n if beta is not None:\\n writer.add_scalar(\\\"train/memory_beta\\\", beta, i_episode)\\n agent.memory.beta = min(1., agent.memory.beta + agent.memory.beta_incremental)\\n \\n print(f'\\\\rEpisode {i_episode}\\\\tAverage Score: {window_score:.2f}\\\\tTime: {time_for_episode:.2f}', end=\\\"\\\")\\n \\n if i_episode % 100 == 0:\\n print(f'\\\\rEpisode {i_episode}\\\\tAverage Score: {window_score:.2f}')\\n\\n if window_score >= score_threshold and best_score < score_threshold:\\n print(f'\\\\nEnvironment solved in {i_episode:d} episodes!\\\\tAverage Score: {window_score:.2f}')\\n\\n if window_score > best_score and window_score >= score_threshold:\\n best_score = window_score\\n torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pt')\\n\\n memory_dump = getattr(agent.memory, 'memory', None) \\n if memory_dump is not None: \\n torch.save(memory_dump, \\\"memory.pt\\\")\\n\\n print(f\\\"Best average score: {best_score}\\\")\\n writer.close()\\n return scores\",\n \"def OnEpisodeOver(self):\\n pass\",\n \"def run_episode(env, agents, eval=False, render=False, generate_val_data=False, greedy_eval=True, steps=25, store_data=False, trainer=None):\\n obs_n = env.reset()\\n reward_tot = [0.0 for i in range(len(agents))]\\n reward_n = [0.0 for i in range(len(agents))]\\n done_n = [False for i in range(len(agents))]\\n\\n if store_data:\\n observations = []\\n rewards = []\\n rewards_details = {\\\"rewards_target\\\": [], \\\"rewards_collision\\\": []}\\n actions = []\\n\\n # Start env\\n for i in range(steps):\\n\\n # query for action from each agent's policy\\n act_n = []\\n if store_data or True:\\n observations.append(obs_n)\\n actions.append([])\\n rewards.append(reward_n)\\n # Take actions\\n action_list = []\\n for j, agent in enumerate(agents):\\n action_unscaled = agent.step(obs_n[j], reward_n[j], done=done_n[0], eval=eval,\\n generate_val_data=generate_val_data, greedy_eval=greedy_eval)\\n action_list.append(action_unscaled)\\n if store_data:\\n actions[-1].append(action_unscaled)\\n action = scale_action(env, j, action_unscaled)\\n act_n.append(action)\\n if trainer is not None and not eval:\\n trainer.step(obs_n, reward_n, action_list, done=done_n)\\n # step environment\\n obs_n, reward_n, done_n, info_n = env.step(act_n)\\n\\n for j, r in enumerate(reward_n):\\n reward_tot[j] += r\\n if done_n[0]:\\n for j, agent in enumerate(agents):\\n action = scale_action(env, j, agent.step(obs_n[j], reward_n[j], done=done_n[0], eval=eval,\\n generate_val_data=generate_val_data, greedy_eval=greedy_eval))\\n act_n.append(action)\\n agent.reset()\\n break\\n\\n # render all agent views\\n if render:\\n env.render()\\n for j, agent in enumerate(agents):\\n agent.reset()\\n if trainer is not None:\\n trainer.reset()\\n if not store_data:\\n return reward_tot, i + 1\\n else:\\n extra_data = {\\\"observations\\\": observations, \\\"actions\\\": actions, \\\"rewards\\\": rewards, \\\"rewards_details\\\": rewards_details}\\n return reward_tot, i + 1, extra_data\",\n \"def self_play(self, n_episodes): \\n eps = self.eps(self.agent.learning_iters)\\n experiences = self_play_episodes(self.mdp, self.agent, n_episodes, eps) \\n for state, action, reward, next_state, done in experiences:\\n self.agent.replay_buffer.push(state, action, reward, next_state, done)\",\n \"def generate_episode(env, policy, max_steps):\\n episodes = []\\n state = env.reset()\\n for t in range(max_steps):\\n action = policy(state)\\n new_state, reward, done, _ = env.step(action)\\n\\n if done is True:\\n episodes.append((state, action, 1))\\n break\\n episodes.append((state, action, reward))\\n state = new_state\\n return np.array(episodes, np.object)\",\n \"def _generator(self):\\n # Initial setup\\n ac = self._env.action_space.sample() # not used, just so we have the datatype\\n self.new = True # marks if we're on first timestep of an episode\\n self.ob = self._convert_state(self._env.reset()) \\n T = self._timesteps\\n\\n cur_ep_ret = 0 # return in current episode\\n cur_ep_len = 0 # len of current episode\\n ep_rets = [] # returns of completed episodes in this segment\\n ep_lens = [] # lengths of ...\\n\\n # Initialize history arrays\\n #obs = np.array([None for _ in range(T)])\\n obs = nd.empty((T,) + self._env.observation_space.shape)\\n rews = np.zeros(T, 'float32')\\n vpreds = np.zeros(T, 'float32')\\n news = np.zeros(T, 'int32')\\n acs = np.array([ac for _ in range(T)])\\n prevacs = acs.copy()\\n\\n t = 0\\n while True:\\n ob = self.ob # Use `self.` since `_evaluate` may have reset the env\\n new = self.new\\n prevac = ac\\n ac, vpred = self._act(ob)\\n # NOTE(openAI) Slight weirdness here because we need value function at time T\\n # before returning segment [0, T-1] so we get the correct terminal value\\n if t > 0 and t % T == 0:\\n seg = {\\\"ob\\\": obs, \\\"rew\\\": rews, \\\"vpred\\\": vpreds, \\\"new\\\": news,\\n \\\"ac\\\": acs, \\\"nextvpred\\\": vpred * (1 - new),\\n \\\"ep_rets\\\": np.array(copy.deepcopy(ep_rets)),\\n \\\"ep_lens\\\": np.array(copy.deepcopy(ep_lens))}\\n self._add_vtarg_and_adv(seg, self._gamma, self._lambda)\\n yield seg\\n # NOTE: Do a deepcopy if the values formerly in these arrays are used later.\\n ep_rets = []\\n ep_lens = []\\n i = t % T\\n\\n obs[i] = ob[0]\\n vpreds[i] = vpred\\n news[i] = new\\n acs[i] = ac\\n prevacs[i] = prevac\\n\\n ob, rew, new, _ = self._env.step(ac)\\n ob = self._convert_state(ob)\\n rews[i] = rew\\n\\n cur_ep_ret += rew\\n cur_ep_len += 1\\n if new:\\n ep_rets.append(cur_ep_ret)\\n ep_lens.append(cur_ep_len)\\n cur_ep_ret = 0\\n cur_ep_len = 0\\n ob = self._convert_state(self._env.reset())\\n self.new = new\\n self.ob = ob\\n t += 1\",\n \"def add(self, episode, last_stuff=None):\\n color, depth, action, info = [], [], [], []\\n for obs, act, i in episode:\\n color.append(obs['color'])\\n depth.append(obs['depth'])\\n action.append(act)\\n info.append(i)\\n\\n color = np.uint8(color)\\n depth = np.float32(depth)\\n\\n def dump(data, field):\\n field_path = os.path.join(self.path, field)\\n if not os.path.exists(field_path):\\n os.makedirs(field_path)\\n fname = f'{self.num_episodes:06d}-{len(episode)}.pkl'\\n pickle.dump(data, open(os.path.join(field_path, fname), 'wb'))\\n\\n dump(color, 'color')\\n dump(depth, 'depth')\\n dump(action, 'action')\\n dump(info, 'info')\\n\\n # Handle last stuff.\\n if last_stuff is not None:\\n last_color = np.uint8(last_stuff[0]['color'])\\n last_depth = np.float32(last_stuff[0]['depth'])\\n dump(last_color, 'last_color')\\n dump(last_depth, 'last_depth')\\n dump(last_stuff[1], 'last_info')\\n else:\\n print('Warning! last_stuff=None. We may require this later.')\\n\\n self.episode_id += [self.num_episodes] * len(episode)\",\n \"def train(Game, agent, episodes=1000):\\n a = agent\\n # eps_start = a.epsilon\\n # eps_end = a.epsilon_min\\n # eps_dec = np.exp(1/episodes * np.log(eps_end/eps_start))\\n # a.epsilon_decrement = eps_dec\\n times_taken = np.zeros(episodes)\\n print(\\\"Training starting\\\")\\n for n in range(episodes):\\n start_time = time.time()\\n g = Game()\\n print(\\\"EPISODE\\\", n+1)\\n while not g.success:\\n state = 1.0*g.get_state()\\n action = a.action(state)\\n reward = g.play(action)\\n # print(g.success)\\n # print(\\\"reward: \\\", reward)\\n # print(state)\\n # print(action)\\n # print(g.get_state())\\n a.train(state, action, reward, g.get_state(), g.success)\\n end_time = time.time()\\n times_taken[n] = end_time - start_time\\n print(\\\"Training complete ({} episodes)\\\".format(episodes))\\n return times_taken\",\n \"def run_episode(env, agent, deterministic, skip_frames=0, do_training=True, rendering=False,\\n max_timesteps=1000, history_length=0):\\n\\n stats = EpisodeStats()\\n\\n # Save history\\n image_hist = []\\n\\n step = 0\\n state = env.reset()\\n\\n # fix bug of corrupted states without rendering in gym environment\\n env.viewer.window.dispatch_events()\\n\\n # append image history to first state\\n state = state_preprocessing(state)\\n image_hist.extend([state] * history_length)\\n state = np.array(image_hist)#.reshape(96, 96, history_length)\\n\\n while True:\\n\\n # TODO: get action_id from agent\\n # Hint: adapt the probabilities of the 5 actions for random sampling so that the agent explores properly. \\n # action_id = agent.act(...)\\n # action = your_id_to_action_method(...)\\n action_id = agent.act(state, deterministic)\\n action = id_to_action(action_id)\\n\\n # Hint: frame skipping might help you to get better results.\\n reward = 0\\n for _ in range(skip_frames + 1):\\n next_state, r, terminal, info = env.step(action)\\n reward += r\\n\\n if rendering:\\n env.render()\\n\\n if terminal:\\n break\\n\\n next_state = state_preprocessing(next_state)\\n image_hist.append(next_state)\\n image_hist.pop(0)\\n next_state = np.array(image_hist)#.reshape(96, 96, history_length)\\n\\n if do_training:\\n agent.train(state, action_id, next_state, reward, terminal)\\n\\n stats.step(reward, action_id)\\n\\n state = next_state\\n\\n if terminal or (step * (skip_frames + 1)) > max_timesteps:\\n break\\n\\n step += 1\\n\\n return stats\",\n \"def iterate(agents, E, t, episode_nr):\\n global batch_size\\n # print('I am inside one time step!')\\n terminal_list = []\\n for agent in agents:\\n S = State(E, [agent.m, agent.n])\\n if not agent.carry:\\n\\n S_new, action_number, r, terminal = agent.move_agent(S) # Moves agent\\n\\n agent.steps += 1\\n agent.reward += r\\n\\n e = (S, action_number, r, S_new, terminal)\\n agent.memory.append(e)\\n\\n E = S_new.grid # Update environment\\n\\n if len(agent.memory) > batch_size:\\n batch = sample_batch(agent.memory, batch_size)\\n agent.train_network(batch, episode_nr)\\n\\n terminal_list.append(terminal)\\n\\n if t % 50 == 0: # Choose time interval for updating target network weights\\n agent.update_target_network()\\n\\n # print(E) # Show grid\\n # print()\\n\\n # if episode_nr > 5:\\n # show_grid(E, episode_nr)\\n\\n # show_grid(E, episode_nr)\\n\\n terminal = np.all(terminal_list) # True if all agents have reached destination\\n env_list.append(E)\\n\\n return E, terminal\",\n \"def get_aggregate(self, episode_queryset):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6414621","0.63026017","0.6240498","0.6224731","0.6224731","0.6215807","0.6149335","0.6149335","0.6086121","0.6048319","0.6045558","0.6028511","0.6001478","0.5987351","0.59605205","0.59348625","0.58955103","0.5888853","0.5848818","0.5830826","0.5825047","0.58134794","0.57712436","0.57524085","0.57412565","0.5740557","0.57373846","0.5736909","0.5735947","0.57316244","0.57152176","0.5700351","0.5695085","0.56777906","0.56766415","0.5672299","0.5672078","0.5668923","0.56608367","0.5647429","0.56383574","0.56372935","0.5624318","0.5609296","0.56004834","0.5578411","0.55668926","0.55632704","0.5562791","0.5562791","0.5542674","0.55407566","0.55390334","0.55384326","0.5537512","0.55359554","0.55233896","0.5522711","0.5516397","0.551369","0.5511208","0.55111563","0.55089283","0.55078894","0.5503038","0.54961467","0.5486003","0.54836845","0.5474538","0.54561216","0.54546005","0.54514575","0.5449138","0.5439596","0.54345846","0.54238236","0.5411616","0.5410093","0.5407715","0.5407347","0.54052716","0.54029554","0.5400955","0.5377569","0.53726196","0.5370383","0.5368308","0.53664505","0.5359248","0.5355454","0.5334276","0.53067374","0.5301916","0.5294512","0.52916485","0.5284518","0.528274","0.5281057","0.52737534","0.5270876"],"string":"[\n \"0.6414621\",\n \"0.63026017\",\n \"0.6240498\",\n \"0.6224731\",\n \"0.6224731\",\n \"0.6215807\",\n \"0.6149335\",\n \"0.6149335\",\n \"0.6086121\",\n \"0.6048319\",\n \"0.6045558\",\n \"0.6028511\",\n \"0.6001478\",\n \"0.5987351\",\n \"0.59605205\",\n \"0.59348625\",\n \"0.58955103\",\n \"0.5888853\",\n \"0.5848818\",\n \"0.5830826\",\n \"0.5825047\",\n \"0.58134794\",\n \"0.57712436\",\n \"0.57524085\",\n \"0.57412565\",\n \"0.5740557\",\n \"0.57373846\",\n \"0.5736909\",\n \"0.5735947\",\n \"0.57316244\",\n \"0.57152176\",\n \"0.5700351\",\n \"0.5695085\",\n \"0.56777906\",\n \"0.56766415\",\n \"0.5672299\",\n \"0.5672078\",\n \"0.5668923\",\n \"0.56608367\",\n \"0.5647429\",\n \"0.56383574\",\n \"0.56372935\",\n \"0.5624318\",\n \"0.5609296\",\n \"0.56004834\",\n \"0.5578411\",\n \"0.55668926\",\n \"0.55632704\",\n \"0.5562791\",\n \"0.5562791\",\n \"0.5542674\",\n \"0.55407566\",\n \"0.55390334\",\n \"0.55384326\",\n \"0.5537512\",\n \"0.55359554\",\n \"0.55233896\",\n \"0.5522711\",\n \"0.5516397\",\n \"0.551369\",\n \"0.5511208\",\n \"0.55111563\",\n \"0.55089283\",\n \"0.55078894\",\n \"0.5503038\",\n \"0.54961467\",\n \"0.5486003\",\n \"0.54836845\",\n \"0.5474538\",\n \"0.54561216\",\n \"0.54546005\",\n \"0.54514575\",\n \"0.5449138\",\n \"0.5439596\",\n \"0.54345846\",\n \"0.54238236\",\n \"0.5411616\",\n \"0.5410093\",\n \"0.5407715\",\n \"0.5407347\",\n \"0.54052716\",\n \"0.54029554\",\n \"0.5400955\",\n \"0.5377569\",\n \"0.53726196\",\n \"0.5370383\",\n \"0.5368308\",\n \"0.53664505\",\n \"0.5359248\",\n \"0.5355454\",\n \"0.5334276\",\n \"0.53067374\",\n \"0.5301916\",\n \"0.5294512\",\n \"0.52916485\",\n \"0.5284518\",\n \"0.528274\",\n \"0.5281057\",\n \"0.52737534\",\n \"0.5270876\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.616832"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":14896,"cells":{"query":{"kind":"string","value":"Train and convert the model using TF Agents."},"document":{"kind":"string","value":"def train_agent(iterations, modeldir, logdir, policydir):\n\n # TODO: add code to instantiate the training and evaluation environments\n\n\n # TODO: add code to create a reinforcement learning agent that is going to be trained\n\n\n tf_agent.initialize()\n\n eval_policy = tf_agent.policy\n collect_policy = tf_agent.collect_policy\n\n tf_policy_saver = policy_saver.PolicySaver(collect_policy)\n\n # Use reverb as replay buffer\n replay_buffer_signature = tensor_spec.from_spec(tf_agent.collect_data_spec)\n replay_buffer_signature = tensor_spec.add_outer_dim(replay_buffer_signature)\n table = reverb.Table(\n REPLAY_BUFFER_TABLE_NAME,\n max_size=REPLAY_BUFFER_CAPACITY,\n sampler=reverb.selectors.Uniform(),\n remover=reverb.selectors.Fifo(),\n rate_limiter=reverb.rate_limiters.MinSize(1),\n signature=replay_buffer_signature,\n ) # specify signature here for validation at insertion time\n\n reverb_server = reverb.Server([table])\n\n replay_buffer = reverb_replay_buffer.ReverbReplayBuffer(\n tf_agent.collect_data_spec,\n sequence_length=None,\n table_name=REPLAY_BUFFER_TABLE_NAME,\n local_server=reverb_server,\n )\n\n replay_buffer_observer = reverb_utils.ReverbAddEpisodeObserver(\n replay_buffer.py_client, REPLAY_BUFFER_TABLE_NAME, REPLAY_BUFFER_CAPACITY\n )\n\n # Optimize by wrapping some of the code in a graph using TF function.\n tf_agent.train = common.function(tf_agent.train)\n\n # Evaluate the agent's policy once before training.\n avg_return = compute_avg_return_and_steps(\n eval_env, tf_agent.policy, NUM_EVAL_EPISODES\n )\n\n summary_writer = tf.summary.create_file_writer(logdir)\n\n for i in range(iterations):\n # TODO: add code to collect game episodes and train the agent\n\n\n logger = tf.get_logger()\n if i % EVAL_INTERVAL == 0:\n avg_return, avg_episode_length = compute_avg_return_and_steps(\n eval_env, eval_policy, NUM_EVAL_EPISODES\n )\n with summary_writer.as_default():\n tf.summary.scalar(\"Average return\", avg_return, step=i)\n tf.summary.scalar(\"Average episode length\", avg_episode_length, step=i)\n summary_writer.flush()\n logger.info(\n \"iteration = {0}: Average Return = {1}, Average Episode Length = {2}\".format(\n i, avg_return, avg_episode_length\n )\n )\n\n summary_writer.close()\n\n tf_policy_saver.save(policydir)"},"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 trainModel( self, featureTrain, classTrain):","def run(self) -> None:\n self.model = self.trainer.train_model(self.model, self.data)","def training(self) -> None:\n self.compile_model()\n self.train_epoch()\n self.agent.save()","def train(self):\n self.emission_model(self.train_data)\n self.transition_model(self.train_data)","def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)","def train(self, training_data, model_name):\n dataset = []\n for example in training_data:\n entity_offsets = self._convert_example(example)\n dataset.append(self._from_json_to_crf(example, entity_offsets))\n\n features = [self._sentence_to_features(s) for s in dataset]\n labels = [self._sentence_to_labels(s) for s in dataset]\n trainer = sklearn_crfsuite.CRF(\n algorithm=\"lbfgs\",\n # coefficient for L1 penalty\n c1=0.1,\n # coefficient for L2 penalty\n c2=0.1,\n # stop earlier\n max_iterations=50,\n # include transitions that are possible, but not observed\n all_possible_transitions=True,\n )\n trainer.fit(features, labels)\n logger.info(\"Creating Model for Intent %s\",model_name)\n joblib.dump(trainer, 'core/agent/model_files/%s.model' % model_name)\n return True","def train_lm():\n\n print(\"\\n\\nTraining started at {} - {}\\n\\n\".format(\n time.strftime(\"%d/%m/%Y\"), time.strftime(\"%H:%M:%S\")\n ))\n\n config = get_config(FLAGS.config)\n\n vocabulary = read_vocabulary(config.data_files, config.vocab_size)\n train_data, valid_data, test_data = read_lm_data(config.data_files,\n vocabulary)\n\n with tf.Graph().as_default() as graph:\n\n # define a default initializer for the model\n initializer = tf.random_uniform_initializer(\n -config.init_scale, config.init_scale, seed=seed, dtype=tf.float32)\n\n # model for training\n print(\"\\nBuilding Model for training...\")\n with tf.name_scope(\"Train\"):\n with tf.variable_scope(\"Model\", reuse=None, initializer=initializer):\n\n train_data_producer = lm_data_producer(train_data,\n config.batch_size,\n config.num_steps)\n\n train_queue = tf.FIFOQueue(\n capacity=len(train_data_producer[0]), dtypes=[tf.int32, tf.int32],\n shapes=[[config.num_steps]] * 2)\n\n train_inputs = tf.convert_to_tensor(train_data_producer[0],\n dtype=tf.int32)\n train_targets = tf.convert_to_tensor(train_data_producer[1],\n dtype=tf.int32)\n enqueue_op_train = train_queue.enqueue_many([train_inputs,\n train_targets])\n\n qr_train = tf.train.QueueRunner(train_queue, [enqueue_op_train] * 2)\n tf.train.add_queue_runner(qr_train)\n\n mtrain = AttentiveLM(is_training=True,\n params=config,\n batch_size=config.batch_size,\n num_steps=config.num_steps,\n queue=train_queue,\n keep_attention_weights=False,\n log_tensorboard=FLAGS.log_tensorboard)\n print(\"Batch size: {:d}\".format(mtrain.batch_size))\n print(\"# of steps: {:d}\".format(mtrain.num_steps))\n\n # model for validation\n print(\"\\nBuilding Model for validation...\")\n with tf.name_scope(\"Valid\"):\n with tf.variable_scope(\"Model\", reuse=True, initializer=initializer):\n\n num_valid_steps = max([len(sample) for sample in valid_data])\n valid_data_producer = lm_data_producer(\n valid_data, config.batch_size, num_valid_steps)\n\n valid_queue = tf.FIFOQueue(\n capacity=len(valid_data_producer[0]), dtypes=[tf.int32, tf.int32],\n shapes=[[num_valid_steps]] * 2)\n\n valid_inputs = tf.convert_to_tensor(\n valid_data_producer[0], dtype=tf.int32)\n valid_targets = tf.convert_to_tensor(\n valid_data_producer[1], dtype=tf.int32)\n enqueue_op_valid = valid_queue.enqueue_many(\n [valid_inputs, valid_targets])\n\n qr_valid = tf.train.QueueRunner(valid_queue, [enqueue_op_valid] * 2)\n tf.train.add_queue_runner(qr_valid)\n\n mvalid = AttentiveLM(\n is_training=False, params=config, batch_size=config.batch_size,\n num_steps=num_valid_steps, queue=valid_queue,\n keep_attention_weights=False)\n print(\"# of validation steps: {:d}\".format(num_valid_steps))\n\n # configure the session\n proto_config = tf.ConfigProto(allow_soft_placement=True,\n log_device_placement=False)\n\n # save training and best models\n saver = tf.train.Saver(max_to_keep=3)\n saver_best = tf.train.Saver(max_to_keep=1)\n\n supervisor = tf.train.Supervisor(logdir=FLAGS.train_dir,\n saver=saver, save_model_secs=0)\n\n with supervisor.managed_session(config=proto_config) as session:\n\n # supervisor.\n\n best_valid_ppx = np.inf\n estop_counter = 0\n\n for epoch in range(FLAGS.max_epochs):\n\n lr_decay = config.lr_decay ** max(epoch - config.start_decay, 0.0)\n mtrain.assign_lr(session, config.learning_rate * lr_decay)\n\n # print info\n print(\"\\nEpoch: {:d} - Learning rate: {:e}\".format(\n epoch, session.run(mtrain.lr_rate)))\n\n _ = run_epoch(session, mtrain, train_data, is_train=True)\n\n # Save checkpoint\n print(\"\\nSaving current model...\")\n checkpoint_path = os.path.join(FLAGS.train_dir, FLAGS.model_name)\n saver.save(session, checkpoint_path, global_step=mtrain.global_step)\n\n print(\"\\nRunning validation...\")\n valid_ppx = run_epoch(session, mvalid, valid_data, is_train=False)\n print(\"Epoch {:d}: - Valid Perplexity: {:.8f}\".format(epoch, valid_ppx))\n\n # check early stop\n if FLAGS.early_stop_patience > 0:\n\n if best_valid_ppx > valid_ppx:\n best_valid_ppx = valid_ppx\n estop_counter = 0\n print('\\nSaving the best model so far...')\n model_name = FLAGS.model_name + '-best'\n best_model_path = os.path.join(FLAGS.best_models_dir, model_name)\n saver_best.save(session, best_model_path,\n global_step=mtrain.global_step)\n else:\n estop_counter += 1\n\n print(\"\\n\\tbest valid. ppx: {:.8f}\".format(best_valid_ppx))\n print(\"early stop patience: {:d} - max {:d}\\n\".format(\n estop_counter, FLAGS.early_stop_patience))\n\n if estop_counter >= FLAGS.early_stop_patience:\n print('\\nEARLY STOP!\\n')\n supervisor.request_stop()\n supervisor.coord.join(threads)\n break\n\n # when we ran the right number of epochs or we reached early stop we\n # finish training\n print(\"\\n\\nTraining finished at {} - {}\\n\\n\".format(\n time.strftime(\"%d/%m/%Y\"), time.strftime(\"%H:%M:%S\")\n ))\n\n with tf.Graph().as_default() as test_graph:\n\n # model for testing\n print(\"\\n\\nBuilding Model for testing...\\n\")\n with tf.name_scope(\"Test\"):\n with tf.variable_scope(\"Model\", reuse=None, initializer=initializer):\n num_test_steps = max([len(sample) for sample in test_data])\n\n test_data_producer = lm_data_producer(\n test_data, config.batch_size, num_test_steps)\n\n test_queue = tf.FIFOQueue(\n capacity=len(test_data_producer[0]), dtypes=[tf.int32, tf.int32],\n shapes=[[num_test_steps]] * 2)\n\n test_inputs = tf.convert_to_tensor(\n test_data_producer[0], dtype=tf.int32)\n test_targets = tf.convert_to_tensor(\n test_data_producer[1], dtype=tf.int32)\n enqueue_op_test = test_queue.enqueue_many(\n [test_inputs, test_targets])\n\n qr_test = tf.train.QueueRunner(test_queue, [enqueue_op_test] * 2)\n tf.train.add_queue_runner(qr_test)\n mtest = AttentiveLM(is_training=False,\n params=config,\n batch_size=config.batch_size,\n num_steps=num_test_steps,\n keep_attention_weights=True)\n print(\"# of test steps: {:d}\".format(num_test_steps))\n\n saver_test = tf.train.Saver(max_to_keep=1)\n test_supervisor = tf.train.Supervisor(\n logdir=FLAGS.best_models_dir, summary_writer=None,\n saver=saver_test, save_model_secs=0)\n\n with test_supervisor.managed_session(config=proto_config) as test_session:\n # eval on test\n print(\"\\nRunning test...\")\n test_ppx = run_epoch(\n test_session, mtest, test_data,\n is_train=False, plot_attention_weights=True)\n print(\"Test Perplexity: {:.8f}\".format(test_ppx))\n\n test_supervisor.request_stop()\n test_supervisor.coord.join()\n\n sys.stdout.flush()","def train(self):\n p = self._params\n if self.train_data != None:\n tens_to_log = self.params.tens_to_log\n logging_hook = tf.train.LoggingTensorHook(tensors = tens_to_log,\n every_n_iter = p.logging_step,\n )\n t_fn = tf.estimator.inputs.numpy_input_fn(x = {\"x\": self.train_data[\"x\"]},\n y = self.train_data[\"y\"],\n batch_size = p.batch_size,\n num_epochs = None,\n shuffle = True,\n )\n self._model.train(input_fn = t_fn,\n steps = self.params.training_steps,\n hooks = [logging_hook],\n )\n \n if self.eval_data != None:\n e_fn = tf.estimator.inputs.numpy_input_fn(x = {\"x\": self.eval_data[\"x\"]},\n y = self.eval_data[\"y\"],\n num_epochs = 1,\n shuffle = False,\n )\n eval_results = self.model.evaluate(input_fn = e_fn,\n checkpoint_path = self.model_dir,\n )\n print(eval_results)","def train(self):\n # self.recognizer.train()\n self.detector.train()\n self.shared_conv.train()","def train(self, training_data, cfg=None, **kwargs):\r\n # type: (TrainingData, Optional[RasaNLUModelConfig], **Any) -> None\r\n\r\n intent_dict = self._create_intent_dict(training_data)\r\n\r\n if len(intent_dict) < 2:\r\n logger.error(\"Can not train an intent classifier. \"\r\n \"Need at least 2 different classes. \"\r\n \"Skipping training of intent classifier.\")\r\n return\r\n\r\n self.inv_intent_dict = {v: k for k, v in intent_dict.items()}\r\n self.encoded_all_intents = self._create_encoded_intents(intent_dict)\r\n\r\n X, Y, intents_for_X = self._prepare_data_for_training(training_data, intent_dict)\r\n\r\n num_classes = len(intent_dict)\r\n\r\n intents_for_X = intents_for_X.astype(np.int32)\r\n\r\n data_size = len(X)\r\n indices = np.arange(data_size)\r\n train_size = int(data_size*2/3)\r\n\r\n\r\n train_x = X[indices[0:train_size]]\r\n train_y = intents_for_X[indices[0:train_size]]\r\n\r\n\r\n test_x = X[indices[train_size:data_size]]\r\n test_y = intents_for_X[indices[train_size:data_size]]\r\n\r\n\r\n\r\n # define classes number to classified\r\n head = tf.contrib.estimator.multi_class_head(n_classes=num_classes)\r\n\r\n # define feature spec for input x parsing\r\n feature_names = ['a_in']\r\n self.feature_columns = [tf.feature_column.numeric_column(key=k,shape=[1, train_x.shape[1]]) for k in feature_names]\r\n\r\n x_tensor_train = {'a_in': train_x}\r\n x_tensor_test = {'a_in': test_x}\r\n\r\n\r\n # set gpu and tf graph confing\r\n tf.logging.set_verbosity(tf.logging.INFO)\r\n config_proto = self.get_config_proto(self.component_config)\r\n\r\n # sparse_softmax_cross_entropy , build linear classified model\r\n self.estimator = tf.contrib.estimator.LinearEstimator(\r\n head = head,\r\n feature_columns=self.feature_columns,\r\n optimizer='Ftrl',\r\n config=tf.estimator.RunConfig(session_config=config_proto)\r\n )\r\n # train model\r\n self.estimator.train(input_fn=lambda: self.input_fn(x_tensor_train,\r\n train_y,\r\n self.batch_size,\r\n shuffle_num=1000,\r\n mode = tf.estimator.ModeKeys.TRAIN),\r\n max_steps=800)\r\n # evaluate model\r\n results = self.estimator.evaluate(input_fn=lambda: self.input_fn(x_tensor_test,\r\n test_y,\r\n self.batch_size,\r\n shuffle_num=1000,\r\n mode = tf.estimator.ModeKeys.PREDICT))\r\n\r\n logger.info(results)","def train(self, X, y):\n tf.logging.set_verbosity(\n tf.logging.INFO) # comment if you don't want to display the information during training/evaluation\n\n X_train, X_test, y_train, y_test = train_test_split(\n X, y, test_size=self.params[\"TEST_SIZE\"], random_state=42, stratify=y)\n\n self.label_list = y.unique()\n\n train_features = self.sentences_to_features(X_train, y_train)\n test_features = self.sentences_to_features(X_test, y_test)\n if DEBUG:\n print(\"Transformation to features completed\")\n\n num_train_steps = int(\n len(train_features) / self.params[\"BATCH_SIZE\"] * self.params[\"NUM_TRAIN_EPOCHS\"])\n num_warmup_steps = int(\n num_train_steps * self.params[\"WARMUP_PROPORTION\"])\n\n run_config = self.run_config_builder()\n model_fn = self.model_fn_builder(len(self.label_list), self.params[\"LEARNING_RATE\"], num_train_steps,\n num_warmup_steps)\n self.estimator = self.estimator_builder(model_fn, run_config)\n\n train_input_fn = bert.run_classifier.input_fn_builder(features=train_features,\n seq_length=self.params[\"MAX_SEQ_LENGTH\"],\n is_training=True, drop_remainder=False)\n if DEBUG:\n print(\"Beginning Training!\")\n current_time = time.time()\n self.estimator.train(input_fn=train_input_fn,\n max_steps=num_train_steps)\n if DEBUG:\n print(\"Training took time :\", time.time() - current_time,\n \"s, or \", (time.time() - current_time) / 60, \"min\")\n\n self.classifier_trained = True\n\n test_input_fn = run_classifier.input_fn_builder(features=test_features,\n seq_length=self.params[\"MAX_SEQ_LENGTH\"],\n is_training=False, drop_remainder=False)\n\n # apply model on test set and print all metrics\n if DEBUG:\n print(\"Evaluating\")\n self.estimator.evaluate(input_fn=test_input_fn, steps=None)","def train(self) -> None:\n\n # Check if in the saved model path there is already a trained model\n if self.config.TRN_HYPERP[\"save_path\"]:\n if tf.saved_model.contains_saved_model(self.config.TRN_HYPERP[\"save_path\"]):\n print(\"INFO: An existing saved model will be used for inference\\n\")\n else:\n params = {**self.config.TRN_HYPERP, **self.config.DATASET_HYPERP}\n trainer = Trainer(**params)\n\n print(f\"INFO: Starting training ... \\n\")\n start_time = time.time()\n trainer.train()\n print(f\"\\nINFO: Training completed in {round((time.time() - start_time)/60, 2)} minutes.\\n\")\n\n # Instantiate the saved translator for inference\n saved_path = self.config.TRN_HYPERP[\"save_path\"]\n self.saved_translator = tf.saved_model.load(saved_path)\n else:\n print(\"INFO: Path to save model wasn't provided in config file. Can't train the model\\n\")","def _train_model(self):\n self.experiment = EpisodicExperiment(self.task, self.agent)\n n_epochs = int(self.rl_params.n_training_episodes / self.rl_params.n_episodes_per_epoch)\n logger.debug(\"Fitting user model over {} epochs, each {} episodes, total {} episodes.\"\n .format(n_epochs, self.rl_params.n_episodes_per_epoch, n_epochs*self.rl_params.n_episodes_per_epoch))\n for i in range(n_epochs):\n logger.debug(\"RL epoch {}\".format(i))\n self.experiment.doEpisodes(self.rl_params.n_episodes_per_epoch)\n self.agent.learn()\n self.agent.reset() # reset buffers","def train():\n pass","def train_model(self, *args, **kwargs):\n self.model.train(self.training, *args, **kwargs)","def train_nlp(model: ContinualModel, dataset: ContinualDataset,\n args: Namespace) -> None:\n model.net.to(model.device)\n results, results_mask_classes = [], []\n \n model_stash = create_stash(model, args, dataset)\n \n if args.csv_log:\n csv_logger = CsvLogger(dataset.SETTING, dataset.NAME, model.NAME)\n if args.tensorboard:\n tb_logger = TensorboardLogger(args, dataset.SETTING, model_stash)\n model_stash['tensorboard_name'] = tb_logger.get_name()\n \n dataset_copy = get_dataset(args)\n \n for t in range(dataset.N_TASKS):\n model.net.train()\n _, _ = dataset_copy.get_data_loaders()\n if model.NAME != 'icarl' and model.NAME != 'pnn':\n # for forward transfer calculation\n random_results_class, random_results_task = evaluate_nlp(model, dataset_copy)\n \n print(file=sys.stderr)\n # start time\n start_time = time.time()\n for t in range(dataset.N_TASKS):\n model.net.train()\n train_loader, test_loader = dataset.get_data_loaders()\n if hasattr(model, 'begin_task'):\n model.begin_task(dataset)\n if t:\n accs = evaluate_nlp(model, dataset, last=True)\n results[t - 1] = results[t - 1] + accs[0]\n if dataset.SETTING == 'class-il':\n results_mask_classes[t - 1] = results_mask_classes[t - 1] + accs[1]\n for epoch in range(args.n_epochs):\n for i, data in enumerate(train_loader):\n if hasattr(dataset.train_loader.dataset, 'logits'):\n # todo: to add logits\n pass\n else:\n xs, ys, x_token_idxs, x_token_masks, y_token_idxs, y_token_masks, y_idxs = data\n \n x_token_idxs = x_token_idxs.to(model.device)\n x_token_masks = x_token_masks.to(model.device)\n y_token_idxs = y_token_idxs.to(model.device)\n y_token_masks = y_token_masks.to(model.device)\n y_idxs = y_idxs.to(model.device)\n task_id = torch.tensor(t, dtype=torch.int64, requires_grad=False)\n task_id = task_id.to(model.device)\n \n if model.require_task_id:\n loss = model.observe(inputs=x_token_idxs, inputs_mask=x_token_masks, labels=y_idxs,\n labels_name=y_token_idxs, labels_mask=y_token_masks, task_labels=task_id)\n else:\n loss = model.observe(inputs=x_token_idxs, inputs_mask=x_token_masks, labels=y_idxs,\n labels_name=y_token_idxs, labels_mask=y_token_masks)\n \n progress_bar(i, len(train_loader), epoch, t, loss)\n \n if args.tensorboard:\n tb_logger.log_loss(loss, args, epoch, t, i)\n \n model_stash['batch_idx'] = i + 1\n model_stash['epoch_idx'] = epoch + 1\n model_stash['batch_idx'] = 0\n \n model_stash['task_idx'] = t + 1\n model_stash['epoch_idx'] = 0\n \n if hasattr(model, 'end_task'):\n model.end_task(dataset)\n \n # reduce the running freq\n # if (t+1) % args.eval_freq == 0:\n accs = evaluate_nlp(model, dataset)\n results.append(accs[0])\n results_mask_classes.append(accs[1])\n \n mean_acc = np.mean(accs, axis=1)\n print_mean_accuracy(mean_acc, t + 1, dataset.SETTING)\n \n # prob_model\n if args.prob_all_tasks:\n if args.prob_type != \"\":\n for prob_l in range(12):\n prob_l += 1\n if args.prob_type == \"proto\":\n p_accs = prob_proto_nlp(model, dataset, prob_l=prob_l)\n else:\n p_accs = prob_final_nlp(model, dataset, prob_l=prob_l)\n p_mean_acc = np.mean(p_accs, axis=1)\n print(\"task {} prob_l {}: mean_acc {}, masked_mean_acc {}\".format(t + 1,\n prob_l,\n round(p_mean_acc[0], 2),\n round(p_mean_acc[1], 2)))\n if args.csv_log:\n csv_logger.log_task_prob(p_mean_acc, t)\n \n model_stash['mean_accs'].append(mean_acc)\n if args.csv_log:\n csv_logger.log(mean_acc)\n if args.tensorboard:\n tb_logger.log_accuracy(np.array(accs), mean_acc, args, t)\n \n running_time = time.time() - start_time\n \n # prob_model\n if args.prob_type != \"\" and not args.prob_all_tasks:\n for prob_l in range(12):\n prob_l += 1\n if args.prob_type == \"proto\":\n accs = prob_proto_nlp(model, dataset, prob_l=prob_l)\n else:\n accs = prob_final_nlp(model, dataset, prob_l=prob_l)\n mean_acc = np.mean(accs, axis=1)\n print(\"prob_l {}: mean_acc {}, masked_mean_acc {}\".format(prob_l, mean_acc[0], mean_acc[1]))\n if args.csv_log:\n csv_logger.log_prob(mean_acc)\n \n if args.csv_log:\n csv_logger.add_bwt(results, results_mask_classes)\n csv_logger.add_running_time(running_time)\n csv_logger.add_forgetting(results, results_mask_classes)\n if model.NAME != 'icarl' and model.NAME != 'pnn':\n csv_logger.add_fwt(results, random_results_class,\n results_mask_classes, random_results_task)\n \n if args.tensorboard:\n tb_logger.close()\n if args.csv_log:\n csv_logger.write(vars(args))","def train(self, x, t):\n for i in range(self.number_model):\n curr_model = self.all_model[i]\n curr_model.fit(x, t)","def train_model(self, *args, **kwargs):\n raise NotImplementedError","def train(self):\n self.log(f\"{self.cur_file_path}\\t\\tInfo: train method invoked!\")\n self.log(f\"{self.cur_file_path}\\t\\tInfo: training {self.model.__class__.__name__} model!\")\n\n self.model.fit(self.trainX, self.trainY)","def train_model(self):\r\n alpha, accuracy_rate = self.select_model()\r\n # Initialize logistic regression with alpha(learning rate)\r\n lg = logisticregression(C=alpha)\r\n # Train the model.\r\n lg.fit(self.training_data, self.target_data)\r\n # Save the trained model as .pkl file.\r\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\r\n print \"Estimated Parameters of Logistic Regression\"\r\n # Estimated parameters of logistic regression.\r\n print lg.get_params()","def train(self):\n model = TreeTrainer.train(self)\n model['latent'] = self._latent\n model['suffstats'] = {\n 'vert_ss': self._vert_ss,\n 'edge_ss': self._edge_ss,\n 'feat_ss': self._feat_ss,\n }\n return model","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train():\n import training\n\n # Ensure output directories exist\n os.makedirs(os.path.dirname(cfg.scaler_path), exist_ok=True)\n os.makedirs(cfg.model_path, exist_ok=True)\n os.makedirs(cfg.log_path, exist_ok=True)\n\n # Load (standardized) input data and target values\n tr_x, tr_y, _ = _load_data(cfg.training_set, is_training=True)\n val_x, val_y, _ = _load_data(cfg.validation_set)\n\n # Try to create reproducible results\n np.random.seed(cfg.initial_seed)\n\n # Save free parameters to disk\n utils.log_parameters(cfg.training, os.path.join(cfg.model_path,\n 'parameters.json'))\n\n training.train(tr_x, tr_y, val_x, val_y)","def train():\n import trace\n trace.train()","def train(self, model, args):\n if model == self.WORD_DET_RFC:\n return self.train_rfc(args)\n elif model == self.REGRESSION_PARAMS:\n return self.train_bb_reg(args)\n else:\n raise Exception('No model %s exists to train' % model)","def train(self, X_train, y_train):\n self.model.fit(X_train, y_train)","def train_agent(self):\n # Retrieve collected experiences from memory\n experiences = np.array(self.replay.get_all())\n # rewards = np.array([h['reward'] for h in experiences])\n #rewards = experiences[:,2]\n rewards = np.array([r[2] for r in experiences])\n\n # Discount and normalize rewards\n norm_rewards = self.discount_rewards_and_normalize(rewards)\n\n # Shuffle for better learning\n shuffled_experiences = np.random.shuffle(experiences)\n\n # Feed the experiences through the network with rewards to compute and\n # minimize the loss.\n\n feed={\n self.X: [r[0] for r in experiences],\n self.rewards:norm_rewards,\n self.ep_actions:experiences[:,1]\n }\n self.tf_sess.run(self.train,feed_dict=feed)\n\n pass","def train(\n # fmt: off\n lang: (\"Model language\", \"positional\", None, str),\n output_path: (\"Output directory to store model in\", \"positional\", None, Path),\n train_path: (\"Location of JSON-formatted training data\", \"positional\", None, Path),\n dev_path: (\"Location of JSON-formatted development data\", \"positional\", None, Path),\n raw_text: (\"Path to jsonl file with unlabelled text documents.\", \"option\", \"rt\", Path) = None,\n base_model: (\"Name of model to update (optional)\", \"option\", \"b\", str) = None,\n pipeline: (\"Comma-separated names of pipeline components\", \"option\", \"p\", str) = \"tagger,parser,ner\",\n vectors: (\"Model to load vectors from\", \"option\", \"v\", str) = None,\n replace_components: (\"Replace components from base model\", \"flag\", \"R\", bool) = False,\n n_iter: (\"Number of iterations\", \"option\", \"n\", int) = 30,\n n_early_stopping: (\"Maximum number of training epochs without dev accuracy improvement\", \"option\", \"ne\", int) = None,\n n_examples: (\"Number of examples\", \"option\", \"ns\", int) = 0,\n use_gpu: (\"Use GPU\", \"option\", \"g\", int) = -1,\n version: (\"Model version\", \"option\", \"V\", str) = \"0.0.0\",\n meta_path: (\"Optional path to meta.json to use as base.\", \"option\", \"m\", Path) = None,\n init_tok2vec: (\"Path to pretrained weights for the token-to-vector parts of the models. See 'spacy pretrain'. Experimental.\", \"option\", \"t2v\", Path) = None,\n parser_multitasks: (\"Side objectives for parser CNN, e.g. 'dep' or 'dep,tag'\", \"option\", \"pt\", str) = \"\",\n entity_multitasks: (\"Side objectives for NER CNN, e.g. 'dep' or 'dep,tag'\", \"option\", \"et\", str) = \"\",\n noise_level: (\"Amount of corruption for data augmentation\", \"option\", \"nl\", float) = 0.0,\n orth_variant_level: (\"Amount of orthography variation for data augmentation\", \"option\", \"ovl\", float) = 0.0,\n eval_beam_widths: (\"Beam widths to evaluate, e.g. 4,8\", \"option\", \"bw\", str) = \"\",\n gold_preproc: (\"Use gold preprocessing\", \"flag\", \"G\", bool) = False,\n learn_tokens: (\"Make parser learn gold-standard tokenization\", \"flag\", \"T\", bool) = False,\n textcat_multilabel: (\"Textcat classes aren't mutually exclusive (multilabel)\", \"flag\", \"TML\", bool) = False,\n textcat_arch: (\"Textcat model architecture\", \"option\", \"ta\", str) = \"bow\",\n textcat_positive_label: (\"Textcat positive label for binary classes with two labels\", \"option\", \"tpl\", str) = None,\n tag_map_path: (\"Location of JSON-formatted tag map\", \"option\", \"tm\", Path) = None,\n verbose: (\"Display more information for debug\", \"flag\", \"VV\", bool) = False,\n debug: (\"Run data diagnostics before training\", \"flag\", \"D\", bool) = False,\n # fmt: on\n):\n util.fix_random_seed()\n util.set_env_log(verbose)\n\n # Make sure all files and paths exists if they are needed\n train_path = util.ensure_path(train_path)\n dev_path = util.ensure_path(dev_path)\n meta_path = util.ensure_path(meta_path)\n output_path = util.ensure_path(output_path)\n if raw_text is not None:\n raw_text = list(srsly.read_jsonl(raw_text))\n if not train_path or not train_path.exists():\n msg.fail(\"Training data not found\", train_path, exits=1)\n if not dev_path or not dev_path.exists():\n msg.fail(\"Development data not found\", dev_path, exits=1)\n if meta_path is not None and not meta_path.exists():\n msg.fail(\"Can't find model meta.json\", meta_path, exits=1)\n meta = srsly.read_json(meta_path) if meta_path else {}\n if output_path.exists() and [p for p in output_path.iterdir() if p.is_dir()]:\n msg.warn(\n \"Output directory is not empty\",\n \"This can lead to unintended side effects when saving the model. \"\n \"Please use an empty directory or a different path instead. If \"\n \"the specified output path doesn't exist, the directory will be \"\n \"created for you.\",\n )\n if not output_path.exists():\n output_path.mkdir()\n msg.good(f\"Created output directory: {output_path}\")\n\n tag_map = {}\n if tag_map_path is not None:\n tag_map = srsly.read_json(tag_map_path)\n # Take dropout and batch size as generators of values -- dropout\n # starts high and decays sharply, to force the optimizer to explore.\n # Batch size starts at 1 and grows, so that we make updates quickly\n # at the beginning of training.\n dropout_rates = util.decaying(\n util.env_opt(\"dropout_from\", 0.2),\n util.env_opt(\"dropout_to\", 0.2),\n util.env_opt(\"dropout_decay\", 0.0),\n )\n batch_sizes = util.compounding(\n util.env_opt(\"batch_from\", 100.0),\n util.env_opt(\"batch_to\", 1000.0),\n util.env_opt(\"batch_compound\", 1.001),\n )\n\n if not eval_beam_widths:\n eval_beam_widths = [1]\n else:\n eval_beam_widths = [int(bw) for bw in eval_beam_widths.split(\",\")]\n if 1 not in eval_beam_widths:\n eval_beam_widths.append(1)\n eval_beam_widths.sort()\n has_beam_widths = eval_beam_widths != [1]\n\n default_dir = Path(__file__).parent.parent / \"ml\" / \"models\" / \"defaults\"\n\n # Set up the base model and pipeline. If a base model is specified, load\n # the model and make sure the pipeline matches the pipeline setting. If\n # training starts from a blank model, intitalize the language class.\n pipeline = [p.strip() for p in pipeline.split(\",\")]\n msg.text(f\"Training pipeline: {pipeline}\")\n disabled_pipes = None\n pipes_added = False\n if use_gpu >= 0:\n activated_gpu = None\n try:\n activated_gpu = set_gpu(use_gpu)\n except Exception as e:\n msg.warn(f\"Exception: {e}\")\n if activated_gpu is not None:\n msg.text(f\"Using GPU: {use_gpu}\")\n else:\n msg.warn(f\"Unable to activate GPU: {use_gpu}\")\n msg.text(\"Using CPU only\")\n use_gpu = -1\n if base_model:\n msg.text(f\"Starting with base model '{base_model}'\")\n nlp = util.load_model(base_model)\n if nlp.lang != lang:\n msg.fail(\n f\"Model language ('{nlp.lang}') doesn't match language \"\n f\"specified as `lang` argument ('{lang}') \",\n exits=1,\n )\n if vectors:\n msg.text(f\"Loading vectors from model '{vectors}'\")\n _load_vectors(nlp, vectors)\n\n nlp.select_pipes(disable=[p for p in nlp.pipe_names if p not in pipeline])\n for pipe in pipeline:\n # first, create the model.\n # Bit of a hack after the refactor to get the vectors into a default config\n # use train-from-config instead :-)\n if pipe == \"parser\":\n config_loc = default_dir / \"parser_defaults.cfg\"\n elif pipe == \"tagger\":\n config_loc = default_dir / \"tagger_defaults.cfg\"\n elif pipe == \"ner\":\n config_loc = default_dir / \"ner_defaults.cfg\"\n elif pipe == \"textcat\":\n config_loc = default_dir / \"textcat_defaults.cfg\"\n elif pipe == \"senter\":\n config_loc = default_dir / \"senter_defaults.cfg\"\n else:\n raise ValueError(f\"Component {pipe} currently not supported.\")\n pipe_cfg = util.load_config(config_loc, create_objects=False)\n if vectors:\n pretrained_config = {\n \"@architectures\": \"spacy.VocabVectors.v1\",\n \"name\": vectors,\n }\n pipe_cfg[\"model\"][\"tok2vec\"][\"pretrained_vectors\"] = pretrained_config\n\n if pipe == \"parser\":\n pipe_cfg[\"learn_tokens\"] = learn_tokens\n elif pipe == \"textcat\":\n pipe_cfg[\"exclusive_classes\"] = not textcat_multilabel\n pipe_cfg[\"architecture\"] = textcat_arch\n pipe_cfg[\"positive_label\"] = textcat_positive_label\n\n if pipe not in nlp.pipe_names:\n msg.text(f\"Adding component to base model '{pipe}'\")\n nlp.add_pipe(nlp.create_pipe(pipe, config=pipe_cfg))\n pipes_added = True\n elif replace_components:\n msg.text(f\"Replacing component from base model '{pipe}'\")\n nlp.replace_pipe(pipe, nlp.create_pipe(pipe, config=pipe_cfg))\n pipes_added = True\n else:\n if pipe == \"textcat\":\n textcat_cfg = nlp.get_pipe(\"textcat\").cfg\n base_cfg = {\n \"exclusive_classes\": textcat_cfg[\"exclusive_classes\"],\n \"architecture\": textcat_cfg[\"architecture\"],\n \"positive_label\": textcat_cfg[\"positive_label\"],\n }\n if base_cfg != pipe_cfg:\n msg.fail(\n f\"The base textcat model configuration does\"\n f\"not match the provided training options. \"\n f\"Existing cfg: {base_cfg}, provided cfg: {pipe_cfg}\",\n exits=1,\n )\n msg.text(f\"Extending component from base model '{pipe}'\")\n disabled_pipes = nlp.select_pipes(\n disable=[p for p in nlp.pipe_names if p not in pipeline]\n )\n else:\n msg.text(f\"Starting with blank model '{lang}'\")\n lang_cls = util.get_lang_class(lang)\n nlp = lang_cls()\n\n if vectors:\n msg.text(f\"Loading vectors from model '{vectors}'\")\n _load_vectors(nlp, vectors)\n\n for pipe in pipeline:\n # first, create the model.\n # Bit of a hack after the refactor to get the vectors into a default config\n # use train-from-config instead :-)\n if pipe == \"parser\":\n config_loc = default_dir / \"parser_defaults.cfg\"\n elif pipe == \"tagger\":\n config_loc = default_dir / \"tagger_defaults.cfg\"\n elif pipe == \"morphologizer\":\n config_loc = default_dir / \"morphologizer_defaults.cfg\"\n elif pipe == \"ner\":\n config_loc = default_dir / \"ner_defaults.cfg\"\n elif pipe == \"textcat\":\n config_loc = default_dir / \"textcat_defaults.cfg\"\n elif pipe == \"senter\":\n config_loc = default_dir / \"senter_defaults.cfg\"\n else:\n raise ValueError(f\"Component {pipe} currently not supported.\")\n pipe_cfg = util.load_config(config_loc, create_objects=False)\n if vectors:\n pretrained_config = {\n \"@architectures\": \"spacy.VocabVectors.v1\",\n \"name\": vectors,\n }\n pipe_cfg[\"model\"][\"tok2vec\"][\"pretrained_vectors\"] = pretrained_config\n\n if pipe == \"parser\":\n pipe_cfg[\"learn_tokens\"] = learn_tokens\n elif pipe == \"textcat\":\n pipe_cfg[\"exclusive_classes\"] = not textcat_multilabel\n pipe_cfg[\"architecture\"] = textcat_arch\n pipe_cfg[\"positive_label\"] = textcat_positive_label\n\n pipe = nlp.create_pipe(pipe, config=pipe_cfg)\n nlp.add_pipe(pipe)\n\n # Update tag map with provided mapping\n nlp.vocab.morphology.tag_map.update(tag_map)\n\n # Multitask objectives\n multitask_options = [(\"parser\", parser_multitasks), (\"ner\", entity_multitasks)]\n for pipe_name, multitasks in multitask_options:\n if multitasks:\n if pipe_name not in pipeline:\n msg.fail(\n f\"Can't use multitask objective without '{pipe_name}' in \"\n f\"the pipeline\"\n )\n pipe = nlp.get_pipe(pipe_name)\n for objective in multitasks.split(\",\"):\n pipe.add_multitask_objective(objective)\n\n # Prepare training corpus\n msg.text(f\"Counting training words (limit={n_examples})\")\n corpus = GoldCorpus(train_path, dev_path, limit=n_examples)\n n_train_words = corpus.count_train()\n\n if base_model and not pipes_added:\n # Start with an existing model, use default optimizer\n optimizer = create_default_optimizer()\n else:\n # Start with a blank model, call begin_training\n cfg = {\"device\": use_gpu}\n optimizer = nlp.begin_training(lambda: corpus.train_examples, **cfg)\n nlp._optimizer = None\n\n # Load in pretrained weights (TODO: this may be broken in the config rewrite)\n if init_tok2vec is not None:\n components = _load_pretrained_tok2vec(nlp, init_tok2vec)\n msg.text(f\"Loaded pretrained tok2vec for: {components}\")\n\n # Verify textcat config\n if \"textcat\" in pipeline:\n textcat_labels = nlp.get_pipe(\"textcat\").cfg.get(\"labels\", [])\n if textcat_positive_label and textcat_positive_label not in textcat_labels:\n msg.fail(\n f\"The textcat_positive_label (tpl) '{textcat_positive_label}' \"\n f\"does not match any label in the training data.\",\n exits=1,\n )\n if textcat_positive_label and len(textcat_labels) != 2:\n msg.fail(\n \"A textcat_positive_label (tpl) '{textcat_positive_label}' was \"\n \"provided for training data that does not appear to be a \"\n \"binary classification problem with two labels.\",\n exits=1,\n )\n train_data = corpus.train_data(\n nlp,\n noise_level=noise_level,\n gold_preproc=gold_preproc,\n max_length=0,\n ignore_misaligned=True,\n )\n train_labels = set()\n if textcat_multilabel:\n multilabel_found = False\n for ex in train_data:\n train_labels.update(ex.gold.cats.keys())\n if list(ex.gold.cats.values()).count(1.0) != 1:\n multilabel_found = True\n if not multilabel_found and not base_model:\n msg.warn(\n \"The textcat training instances look like they have \"\n \"mutually-exclusive classes. Remove the flag \"\n \"'--textcat-multilabel' to train a classifier with \"\n \"mutually-exclusive classes.\"\n )\n if not textcat_multilabel:\n for ex in train_data:\n train_labels.update(ex.gold.cats.keys())\n if list(ex.gold.cats.values()).count(1.0) != 1 and not base_model:\n msg.warn(\n \"Some textcat training instances do not have exactly \"\n \"one positive label. Modifying training options to \"\n \"include the flag '--textcat-multilabel' for classes \"\n \"that are not mutually exclusive.\"\n )\n nlp.get_pipe(\"textcat\").cfg[\"exclusive_classes\"] = False\n textcat_multilabel = True\n break\n if base_model and set(textcat_labels) != train_labels:\n msg.fail(\n f\"Cannot extend textcat model using data with different \"\n f\"labels. Base model labels: {textcat_labels}, training data \"\n f\"labels: {list(train_labels)}\",\n exits=1,\n )\n if textcat_multilabel:\n msg.text(\n f\"Textcat evaluation score: ROC AUC score macro-averaged across \"\n f\"the labels '{', '.join(textcat_labels)}'\"\n )\n elif textcat_positive_label and len(textcat_labels) == 2:\n msg.text(\n f\"Textcat evaluation score: F1-score for the \"\n f\"label '{textcat_positive_label}'\"\n )\n elif len(textcat_labels) > 1:\n if len(textcat_labels) == 2:\n msg.warn(\n \"If the textcat component is a binary classifier with \"\n \"exclusive classes, provide '--textcat_positive_label' for \"\n \"an evaluation on the positive class.\"\n )\n msg.text(\n f\"Textcat evaluation score: F1-score macro-averaged across \"\n f\"the labels '{', '.join(textcat_labels)}'\"\n )\n else:\n msg.fail(\n \"Unsupported textcat configuration. Use `spacy debug-data` \"\n \"for more information.\"\n )\n\n # fmt: off\n row_head, output_stats = _configure_training_output(pipeline, use_gpu, has_beam_widths)\n row_widths = [len(w) for w in row_head]\n row_settings = {\"widths\": row_widths, \"aligns\": tuple([\"r\" for i in row_head]), \"spacing\": 2}\n # fmt: on\n print(\"\")\n msg.row(row_head, **row_settings)\n msg.row([\"-\" * width for width in row_settings[\"widths\"]], **row_settings)\n try:\n iter_since_best = 0\n best_score = 0.0\n for i in range(n_iter):\n train_data = corpus.train_dataset(\n nlp,\n noise_level=noise_level,\n orth_variant_level=orth_variant_level,\n gold_preproc=gold_preproc,\n max_length=0,\n ignore_misaligned=True,\n )\n if raw_text:\n random.shuffle(raw_text)\n raw_batches = util.minibatch(\n (nlp.make_doc(rt[\"text\"]) for rt in raw_text), size=8\n )\n words_seen = 0\n with tqdm.tqdm(total=n_train_words, leave=False) as pbar:\n losses = {}\n for batch in util.minibatch_by_words(train_data, size=batch_sizes):\n if not batch:\n continue\n try:\n nlp.update(\n batch,\n sgd=optimizer,\n drop=next(dropout_rates),\n losses=losses,\n )\n except ValueError as e:\n err = \"Error during training\"\n if init_tok2vec:\n err += \" Did you provide the same parameters during 'train' as during 'pretrain'?\"\n msg.fail(err, f\"Original error message: {e}\", exits=1)\n if raw_text:\n # If raw text is available, perform 'rehearsal' updates,\n # which use unlabelled data to reduce overfitting.\n raw_batch = list(next(raw_batches))\n nlp.rehearse(raw_batch, sgd=optimizer, losses=losses)\n docs = [ex.doc for ex in batch]\n if not int(os.environ.get(\"LOG_FRIENDLY\", 0)):\n pbar.update(sum(len(doc) for doc in docs))\n words_seen += sum(len(doc) for doc in docs)\n with nlp.use_params(optimizer.averages):\n util.set_env_log(False)\n epoch_model_path = output_path / f\"model{i}\"\n nlp.to_disk(epoch_model_path)\n nlp_loaded = util.load_model_from_path(epoch_model_path)\n for beam_width in eval_beam_widths:\n for name, component in nlp_loaded.pipeline:\n if hasattr(component, \"cfg\"):\n component.cfg[\"beam_width\"] = beam_width\n dev_dataset = list(\n corpus.dev_dataset(\n nlp_loaded,\n gold_preproc=gold_preproc,\n ignore_misaligned=True,\n )\n )\n nwords = sum(len(ex.doc) for ex in dev_dataset)\n start_time = timer()\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\n end_time = timer()\n if use_gpu < 0:\n gpu_wps = None\n cpu_wps = nwords / (end_time - start_time)\n else:\n gpu_wps = nwords / (end_time - start_time)\n with use_ops(\"numpy\"):\n nlp_loaded = util.load_model_from_path(epoch_model_path)\n for name, component in nlp_loaded.pipeline:\n if hasattr(component, \"cfg\"):\n component.cfg[\"beam_width\"] = beam_width\n dev_dataset = list(\n corpus.dev_dataset(\n nlp_loaded,\n gold_preproc=gold_preproc,\n ignore_misaligned=True,\n )\n )\n start_time = timer()\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\n end_time = timer()\n cpu_wps = nwords / (end_time - start_time)\n acc_loc = output_path / f\"model{i}\" / \"accuracy.json\"\n srsly.write_json(acc_loc, scorer.scores)\n\n # Update model meta.json\n meta[\"lang\"] = nlp.lang\n meta[\"pipeline\"] = nlp.pipe_names\n meta[\"spacy_version\"] = f\">={about.__version__}\"\n if beam_width == 1:\n meta[\"speed\"] = {\n \"nwords\": nwords,\n \"cpu\": cpu_wps,\n \"gpu\": gpu_wps,\n }\n meta.setdefault(\"accuracy\", {})\n for component in nlp.pipe_names:\n for metric in _get_metrics(component):\n meta[\"accuracy\"][metric] = scorer.scores[metric]\n else:\n meta.setdefault(\"beam_accuracy\", {})\n meta.setdefault(\"beam_speed\", {})\n for component in nlp.pipe_names:\n for metric in _get_metrics(component):\n meta[\"beam_accuracy\"][metric] = scorer.scores[metric]\n meta[\"beam_speed\"][beam_width] = {\n \"nwords\": nwords,\n \"cpu\": cpu_wps,\n \"gpu\": gpu_wps,\n }\n meta[\"vectors\"] = {\n \"width\": nlp.vocab.vectors_length,\n \"vectors\": len(nlp.vocab.vectors),\n \"keys\": nlp.vocab.vectors.n_keys,\n \"name\": nlp.vocab.vectors.name,\n }\n meta.setdefault(\"name\", f\"model{i}\")\n meta.setdefault(\"version\", version)\n meta[\"labels\"] = nlp.meta[\"labels\"]\n meta_loc = output_path / f\"model{i}\" / \"meta.json\"\n srsly.write_json(meta_loc, meta)\n util.set_env_log(verbose)\n\n progress = _get_progress(\n i,\n losses,\n scorer.scores,\n output_stats,\n beam_width=beam_width if has_beam_widths else None,\n cpu_wps=cpu_wps,\n gpu_wps=gpu_wps,\n )\n if i == 0 and \"textcat\" in pipeline:\n textcats_per_cat = scorer.scores.get(\"textcats_per_cat\", {})\n for cat, cat_score in textcats_per_cat.items():\n if cat_score.get(\"roc_auc_score\", 0) < 0:\n msg.warn(\n f\"Textcat ROC AUC score is undefined due to \"\n f\"only one value in label '{cat}'.\"\n )\n msg.row(progress, **row_settings)\n # Early stopping\n if n_early_stopping is not None:\n current_score = _score_for_model(meta)\n if current_score < best_score:\n iter_since_best += 1\n else:\n iter_since_best = 0\n best_score = current_score\n if iter_since_best >= n_early_stopping:\n msg.text(\n f\"Early stopping, best iteration is: {i - iter_since_best}\"\n )\n msg.text(\n f\"Best score = {best_score}; Final iteration score = {current_score}\"\n )\n break\n except Exception as e:\n msg.warn(f\"Aborting and saving final best model. Encountered exception: {e}\")\n finally:\n best_pipes = nlp.pipe_names\n if disabled_pipes:\n disabled_pipes.restore()\n with nlp.use_params(optimizer.averages):\n final_model_path = output_path / \"model-final\"\n nlp.to_disk(final_model_path)\n meta_loc = output_path / \"model-final\" / \"meta.json\"\n final_meta = srsly.read_json(meta_loc)\n final_meta.setdefault(\"accuracy\", {})\n final_meta[\"accuracy\"].update(meta.get(\"accuracy\", {}))\n final_meta.setdefault(\"speed\", {})\n final_meta[\"speed\"].setdefault(\"cpu\", None)\n final_meta[\"speed\"].setdefault(\"gpu\", None)\n meta.setdefault(\"speed\", {})\n meta[\"speed\"].setdefault(\"cpu\", None)\n meta[\"speed\"].setdefault(\"gpu\", None)\n # combine cpu and gpu speeds with the base model speeds\n if final_meta[\"speed\"][\"cpu\"] and meta[\"speed\"][\"cpu\"]:\n speed = _get_total_speed(\n [final_meta[\"speed\"][\"cpu\"], meta[\"speed\"][\"cpu\"]]\n )\n final_meta[\"speed\"][\"cpu\"] = speed\n if final_meta[\"speed\"][\"gpu\"] and meta[\"speed\"][\"gpu\"]:\n speed = _get_total_speed(\n [final_meta[\"speed\"][\"gpu\"], meta[\"speed\"][\"gpu\"]]\n )\n final_meta[\"speed\"][\"gpu\"] = speed\n # if there were no speeds to update, overwrite with meta\n if (\n final_meta[\"speed\"][\"cpu\"] is None\n and final_meta[\"speed\"][\"gpu\"] is None\n ):\n final_meta[\"speed\"].update(meta[\"speed\"])\n # note: beam speeds are not combined with the base model\n if has_beam_widths:\n final_meta.setdefault(\"beam_accuracy\", {})\n final_meta[\"beam_accuracy\"].update(meta.get(\"beam_accuracy\", {}))\n final_meta.setdefault(\"beam_speed\", {})\n final_meta[\"beam_speed\"].update(meta.get(\"beam_speed\", {}))\n srsly.write_json(meta_loc, final_meta)\n msg.good(\"Saved model to output directory\", final_model_path)\n with msg.loading(\"Creating best model...\"):\n best_model_path = _collate_best_model(final_meta, output_path, best_pipes)\n msg.good(\"Created best model\", best_model_path)","def train(self, X_train, y_train):\n\n self.model_pipeline.fit(X_train, y_train)","def train(self, features, labels):\n pass","def train(self, trnM, trnL):\n print 'Training ...'\n self.clf.fit(trnM, trnL)","async def train(self):","def train_start(self):\n self.module.img_enc.train()\n self.module.txt_enc.train()","def model_fn(features,labels,mode,params):\n tf.logging.info('*** Features ***')\n for name in sorted(features.keys()):\n tf.logging.info(\" name = %s ,shape = %s\" % (name,features[name].shape))\n\n input_ids = features['input_ids']\n input_mask = features['input_mask']\n segment_ids = features['segment_ids']\n label_ids = features['label_ids']\n if 'is_real_example' in features:\n is_real_example = tf.cast(features['is_real_example'],dtype=tf.float32)\n else:\n is_real_example = tf.ones(tf.shape(label_ids),dtype=tf.float32)\n\n is_training = (mode == tf_estimator.estimator.ModeKeys.TRAIN)\n\n (total_loss,per_example_loss,probabilities,predictions) = \\\n create_model(albert_config,is_training,input_ids,input_mask,\n segment_ids,label_ids,num_labels,\n use_one_hot_embeddings)\n\n tvars = tf.trainable_variables()\n initialized_variable_names = {}\n if init_checkpoint:\n (assignment_map,initialized_variable_names) = modeling.get_assignment_map_from_checkpoint(tvars,init_checkpoint)\n tf.train.init_from_checkpoint(init_checkpoint,assignment_map)\n\n tf.logging.info(\"**** Trainable Variables ****\")\n for var in tvars:\n init_string = \"\"\n if var.name in initialized_variable_names:\n init_string = \", *INIT_FROM_CKPT*\"\n tf.logging.info(\" name = %s, shape = %s%s\", var.name, var.shape,\n init_string)\n\n output_spec = None\n if mode == tf_estimator.estimator.ModeKeys.TRAIN:\n train_op = optimization.create_optimizer(total_loss,\n learning_rate,\n num_train_steps,\n num_warmup_steps,use_tpu=False)\n output_spec = tf_estimator.estimator.EstimatorSpec(\n mode=mode,\n loss=total_loss,\n train_op=train_op,\n )\n elif mode == tf_estimator.estimator.ModeKeys.EVAL:\n def metric_fn(per_example_loss,label_ids,logits,is_real_example):\n accuracy = tf.metrics.accuracy(\n labels=label_ids,predictions=predictions,\n weights=is_real_example\n )\n loss = tf.metrics.mean(\n values=per_example_loss,weights=is_real_example\n )\n return {\n 'eval_accuracy':accuracy,\n 'eval_loss':loss,\n }\n\n eval_metrics = metric_fn(per_example_loss,label_ids,predictions,is_real_example)\n output_spec = tf_estimator.estimator.EstimatorSpec(\n mode=mode,\n loss=total_loss,\n eval_metric_ops=eval_metrics\n )\n else:\n output_spec = tf_estimator.estimator.EstimatorSpec(\n mode=mode,\n predictions={\n 'probabilities':probabilities,\n 'predictions':predictions,\n },\n )\n\n return output_spec","def train(self, opts):\n with self._session.as_default(), self._session.graph.as_default():\n self._train_internal(opts)\n self._trained = True","def train(model, train_inputs, train_labels):\n print('Train starts: \\n')\n indices = tf.range(0, train_inputs.shape[0])\n indices = tf.random.shuffle(indices)\n train_inputs = tf.gather(train_inputs, indices)\n train_labels = tf.gather(train_labels, indices)\n\n N = train_inputs.shape[0] // model.batch_size\n for batch in range(N):\n start = batch * model.batch_size\n end = (batch + 1) * model.batch_size\n if (batch + 1) * model.batch_size > train_inputs.shape[0]:\n end = train_inputs.shape[0]\n inputs = train_inputs[start: end]\n labels = train_labels[start: end]\n\n with tf.GradientTape() as tape:\n probs = model.call(inputs)\n loss = model.loss_function(probs, labels)\n\n gradients = tape.gradient(loss, model.trainable_variables)\n model.optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n # if batch % 100 == 0:\n # print('Batch {} starts:'.format(batch))\n print('\\r', \"training processing : {} %\".format((batch + 1) * 100 // N), end='')","def train(self):\n train_dataloader = self.get_train_dataloader()\n\n if self.args.max_steps > 0:\n t_total = self.args.max_steps\n num_train_epochs = (\n self.args.max_steps // (len(train_dataloader) // self.args.gradient_accumulation_steps) + 1\n )\n else:\n t_total = int(len(train_dataloader) // self.args.gradient_accumulation_steps * self.args.num_train_epochs)\n num_train_epochs = self.args.num_train_epochs\n\n lr_scheduler = orttrainer.optim.LinearWarmupLRScheduler(t_total, self.args.warmup_steps / float(t_total))\n\n loss_scaler = amp.DynamicLossScaler() if self.args.fp16 else None\n device = self.args.device.type\n\n device = f\"{device}:{self.args.device.index}\" if self.args.device.index else f\"{device}:0\"\n options = orttrainer.ORTTrainerOptions(\n {\n \"batch\": {\"gradient_accumulation_steps\": self.args.gradient_accumulation_steps},\n \"device\": {\"id\": device},\n \"mixed_precision\": {\"enabled\": self.args.fp16, \"loss_scaler\": loss_scaler},\n \"debug\": {\n \"deterministic_compute\": True,\n },\n \"utils\": {\"grad_norm_clip\": False},\n \"distributed\": {\n # we are running single node multi gpu test. thus world_rank = local_rank\n # and world_size = self.args.n_gpu\n \"world_rank\": max(0, self.args.local_rank),\n \"world_size\": int(self.world_size),\n \"local_rank\": max(0, self.args.local_rank),\n \"allreduce_post_accumulation\": True,\n },\n \"lr_scheduler\": lr_scheduler,\n }\n )\n\n param_optimizer = list(self.model.named_parameters())\n params = [\n {\n \"params\": [n for n, p in param_optimizer if \"bias\" in n or \"LayerNorm.weight\" in n],\n \"weight_decay_mode\": 1,\n },\n {\n \"params\": [n for n, p in param_optimizer if not (\"bias\" in n or \"LayerNorm.weight\" in n)],\n \"weight_decay_mode\": 1,\n },\n ]\n\n optim_config = optim.AdamConfig(params=params, lr=2e-5, do_bias_correction=True)\n self.model = orttrainer.ORTTrainer(self.model, self.model_desc, optim_config, options=options)\n\n # Train!\n logger.info(\"***** Running training *****\")\n logger.info(\" Num examples = %d\", len(train_dataloader.dataset))\n logger.info(\" Num Epochs = %d\", num_train_epochs)\n logger.info(\" Instantaneous batch size per GPU = %d\", self.args.per_gpu_train_batch_size)\n logger.info(\n \" Total train batch size (w. parallel, distributed & accumulation) = %d\",\n self.args.train_batch_size\n * self.args.gradient_accumulation_steps\n * (torch.distributed.get_world_size() if self.args.local_rank != -1 else 1),\n )\n logger.info(\" Gradient Accumulation steps = %d\", self.args.gradient_accumulation_steps)\n logger.info(\" Total optimization steps = %d\", t_total)\n\n global_step = 0\n epochs_trained = 0\n steps_trained_in_current_epoch = 0\n\n tr_loss = 0.0\n logging_loss = 0.0\n train_iterator = trange(\n epochs_trained,\n int(num_train_epochs),\n desc=\"Epoch\",\n disable=self.args.local_rank not in [-1, 0],\n )\n\n for _epoch in train_iterator:\n epoch_iterator = tqdm(train_dataloader, desc=\"Iteration\", disable=self.args.local_rank not in [-1, 0])\n for step, inputs in enumerate(epoch_iterator):\n # Skip past any already trained steps if resuming training\n if steps_trained_in_current_epoch > 0:\n steps_trained_in_current_epoch -= 1\n continue\n\n tr_loss += self._training_step(self.model, inputs)\n\n if (step + 1) % self.args.gradient_accumulation_steps == 0 or (\n len(epoch_iterator) <= self.args.gradient_accumulation_steps and (step + 1) == len(epoch_iterator)\n ):\n global_step += 1\n\n if self.args.local_rank in [-1, 0]:\n if (self.args.logging_steps > 0 and global_step % self.args.logging_steps == 0) or (\n global_step == 1 and self.args.logging_first_step\n ):\n logs = {}\n if self.args.evaluate_during_training:\n results = self.evaluate()\n for key, value in results.items():\n eval_key = f\"eval_{key}\"\n logs[eval_key] = value\n\n loss_scalar = (tr_loss - logging_loss) / self.args.logging_steps\n\n logs[\"loss\"] = loss_scalar\n logging_loss = tr_loss\n\n epoch_iterator.write(json.dumps({**logs, **{\"step\": global_step}}))\n\n if self.args.max_steps > 0 and global_step > self.args.max_steps:\n epoch_iterator.close()\n break\n if self.args.max_steps > 0 and global_step > self.args.max_steps:\n train_iterator.close()\n break\n\n logger.info(\"\\n\\nTraining completed. \\n\\n\")\n return TrainOutput(global_step, tr_loss / global_step)","def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:\n indexer = Indexer()\n stop_words = set(stopwords.words('english'))\n punkt = (',', '.', '...', '?', '\\'', '\\'\\'', '!', ':', ';')\n # Initialize feature extractor\n if args.model == \"TRIVIAL\":\n feat_extractor = None\n elif args.feats == \"UNIGRAM\":\n # Generate vocabulary\n for ex in train_exs:\n for word in ex.words:\n if word.lower() not in stop_words and word.lower() not in punkt:\n indexer.add_and_get_index(word.lower())\n feat_extractor = UnigramFeatureExtractor(indexer)\n elif args.feats == \"BIGRAM\":\n # Generate vocabulary\n for ex in train_exs:\n for i in range(0, len(ex.words) - 1):\n if stop_words.__contains__(ex.words[i]) and stop_words.__contains__(ex.words[i + 1]) or (\n punkt.__contains__(ex.words[i]) or punkt.__contains__(ex.words[i + 1])):\n continue\n bigram = ex.words[i] + ' ' + ex.words[i + 1]\n indexer.add_and_get_index(bigram.lower())\n feat_extractor = BigramFeatureExtractor(indexer)\n elif args.feats == \"BETTER\":\n # Generate vocabulary\n cnt = Counter()\n for ex in train_exs:\n cnt.update(\n word.lower() for word in ex.words if word.lower() not in stop_words and word.lower() not in punkt)\n cnt = dict(cnt.most_common(int(cnt.__len__() * 0.75)))\n for keys in cnt.keys():\n indexer.add_and_get_index(keys)\n feat_extractor = BetterFeatureExtractor(indexer)\n else:\n raise Exception(\"Pass in UNIGRAM, BIGRAM, or BETTER to run the appropriate system\")\n\n # Train the model\n if args.model == \"TRIVIAL\":\n model = TrivialSentimentClassifier()\n elif args.model == \"PERCEPTRON\":\n model = train_perceptron(train_exs, feat_extractor)\n elif args.model == \"LR\":\n model = train_logistic_regression(train_exs, feat_extractor)\n else:\n raise Exception(\"Pass in TRIVIAL, PERCEPTRON, or LR to run the appropriate system\")\n return model","def do_train_automl(**kwargs):\n # instantiate automl client\n automl_client = AutoMlClient()\n\n model_name = clv_automl.create_automl_model(automl_client,\n PROJECT,\n REGION,\n DATASET,\n 'features_n_target',\n AUTOML_DATASET,\n AUTOML_MODEL,\n AUTOML_TRAINING_BUDGET)\n clv_automl.deploy_model(automl_client, model_name)","def train_text_model(train_dir, num_steps):\n if tf.gfile.Exists(train_dir):\n # Delete old model\n tf.gfile.DeleteRecursively(train_dir)\n tf.gfile.MakeDirs(train_dir)\n\n with tf.Graph().as_default():\n model = TextModel(_CONFIG)\n # Specify the loss function:\n one_hot_labels = slim.one_hot_encoding(model.labels, model.nb_emotions)\n slim.losses.softmax_cross_entropy(model.logits, one_hot_labels)\n total_loss = slim.losses.get_total_loss()\n\n # Create some summaries to visualize the training process\n # Use tensorboard --logdir=train_dir, careful with path (add Documents/tumblr-sentiment in front of train_dir)\n # Different from the logs, because computed on different mini batch of data\n tf.summary.scalar('Loss', total_loss)\n \n # Specify the optimizer and create the train op:\n optimizer = tf.train.AdamOptimizer(learning_rate=model.learning_rate)\n train_op = slim.learning.create_train_op(total_loss, optimizer)\n\n batch_size = _CONFIG['batch_size']\n initial_lr = _CONFIG['initial_lr']\n decay_factor = _CONFIG['decay_factor']\n nb_batches = model.dataset.num_samples / batch_size\n def train_step_fn(session, *args, **kwargs):\n # Decaying learning rate every epoch\n if train_step_fn.step % (nb_batches) == 0:\n lr_decay = decay_factor ** train_step_fn.epoch\n session.run(model.lr_rate_assign, feed_dict={model.lr_rate_placeholder: initial_lr * lr_decay})\n print('New learning rate: {0}'. format(initial_lr * lr_decay))\n train_step_fn.epoch += 1\n\n # Initialise embedding weights\n if train_step_fn.step == 0:\n session.run(model.embedding_init, feed_dict={model.embedding_placeholder: model.embedding})\n total_loss, should_stop = train_step(session, *args, **kwargs)\n\n train_step_fn.step += 1\n return [total_loss, should_stop]\n \n train_step_fn.step = 0\n train_step_fn.epoch = 0\n\n # Run the training:\n final_loss = slim.learning.train(\n train_op,\n logdir=train_dir,\n save_interval_secs=600,\n save_summaries_secs=600,\n train_step_fn=train_step_fn,\n number_of_steps=num_steps)\n \n print('Finished training. Last batch loss {0:.3f}'.format(final_loss))","def train():\n\n dataset_train = SequenceDataset(\n subset=\"train\",\n config_dir=FLAGS.config_dir,\n data_dir=FLAGS.data_dir,\n batch_size=FLAGS.batch_size,\n input_size=FLAGS.input_dim,\n output_size=FLAGS.output_dim,\n num_threads=FLAGS.num_threads,\n use_bucket=True,\n infer=False,\n name=\"dataset_train\")()\n\n dataset_valid = SequenceDataset(\n subset=\"valid\",\n config_dir=FLAGS.config_dir,\n data_dir=FLAGS.data_dir,\n batch_size=FLAGS.batch_size,\n input_size=FLAGS.input_dim,\n output_size=FLAGS.output_dim,\n num_threads=FLAGS.num_threads,\n use_bucket=True,\n infer=False,\n name=\"dataset_valid\")()\n\n model = TfModel(\n rnn_cell=FLAGS.rnn_cell,\n dnn_depth=FLAGS.dnn_depth,\n dnn_num_hidden=FLAGS.dnn_num_hidden,\n rnn_depth=FLAGS.rnn_depth,\n rnn_num_hidden=FLAGS.rnn_num_hidden,\n output_size=FLAGS.output_dim,\n bidirectional=FLAGS.bidirectional,\n rnn_output=FLAGS.rnn_output,\n cnn_output=FLAGS.cnn_output,\n look_ahead=FLAGS.look_ahead,\n mdn_output=FLAGS.mdn_output,\n mix_num=FLAGS.mix_num,\n name=\"tf_model\")\n\n # Build a reinitializable iterator for both dataset_train and dataset_valid.\n iterator = tf.data.Iterator.from_structure(\n dataset_train.batched_dataset.output_types,\n dataset_train.batched_dataset.output_shapes)\n (input_sequence, input_sequence_length,\n target_sequence, target_sequence_length) = iterator.get_next()\n\n training_init_op = iterator.make_initializer(dataset_train.batched_dataset)\n validation_init_op = iterator.make_initializer(dataset_valid.batched_dataset)\n\n # Build the model and get the loss.\n output_sequence_logits, train_final_state = model(\n input_sequence, input_sequence_length)\n loss = model.loss(\n output_sequence_logits, target_sequence, target_sequence_length)\n tf.summary.scalar(\"loss\", loss)\n\n learning_rate = tf.get_variable(\n \"learning_rate\",\n shape=[],\n dtype=tf.float32,\n initializer=tf.constant_initializer(FLAGS.learning_rate),\n trainable=False)\n reduce_learning_rate = learning_rate.assign(\n learning_rate * FLAGS.reduce_learning_rate_multiplier)\n\n global_step = tf.get_variable(\n name=\"global_step\",\n shape=[],\n dtype=tf.int64,\n initializer=tf.zeros_initializer(),\n trainable=False,\n collections=[tf.GraphKeys.GLOBAL_VARIABLES, tf.GraphKeys.GLOBAL_STEP])\n\n # Set up optimizer with global norm clipping.\n trainable_variables = tf.trainable_variables()\n optimizer = tf.train.AdamOptimizer(learning_rate)\n grads, _ = tf.clip_by_global_norm(\n tf.gradients(loss, trainable_variables),\n FLAGS.max_grad_norm)\n\n train_step = optimizer.apply_gradients(\n zip(grads, trainable_variables),\n global_step=global_step)\n\n show_all_variables()\n merged_all = tf.summary.merge_all()\n saver = tf.train.Saver(max_to_keep=FLAGS.max_epochs)\n\n # Train\n config = tf.ConfigProto()\n # Prevent exhausting all the gpu memories\n config.gpu_options.allow_growth = True\n with tf.Session(config=config) as sess:\n # Run init\n sess.run(tf.global_variables_initializer())\n\n summary_writer = tf.summary.FileWriter(\n os.path.join(FLAGS.save_dir, \"nnet\"), sess.graph)\n\n if FLAGS.resume_training:\n restore_from_ckpt(sess, saver)\n\n # add a blank line for log readability\n print()\n sys.stdout.flush()\n\n sess.run(validation_init_op)\n loss_prev = eval_one_epoch(sess, loss, dataset_valid.num_batches)\n tf.logging.info(\"CROSSVAL PRERUN AVG.LOSS %.4f\\n\" % loss_prev)\n\n for epoch in range(FLAGS.max_epochs):\n # Train one epoch\n time_start = time.time()\n sess.run(training_init_op)\n tr_loss = train_one_epoch(sess, summary_writer, merged_all, global_step,\n train_step, loss, dataset_train.num_batches)\n time_end = time.time()\n used_time = time_end - time_start\n\n # Validate one epoch\n sess.run(validation_init_op)\n val_loss = eval_one_epoch(sess, loss, dataset_valid.num_batches)\n\n # Determine checkpoint path\n FLAGS.learning_rate = sess.run(learning_rate)\n cptk_name = 'nnet_epoch%d_lrate%g_tr%.4f_cv%.4f' % (\n epoch + 1, FLAGS.learning_rate, tr_loss, val_loss)\n checkpoint_path = os.path.join(FLAGS.save_dir, \"nnet\", cptk_name)\n\n # accept or reject new parameters\n if val_loss < loss_prev:\n saver.save(sess, checkpoint_path)\n # logging training loss along with validation loss\n tf.logging.info(\n \"EPOCH %d: TRAIN AVG.LOSS %.4f, (lrate%g) \"\n \"CROSSVAL AVG.LOSS %.4f, TIME USED %.2f, %s\" % (\n epoch + 1, tr_loss, FLAGS.learning_rate, val_loss,\n used_time, \"nnet accepted\"))\n loss_prev = val_loss\n else:\n tf.logging.info(\n \"EPOCH %d: TRAIN AVG.LOSS %.4f, (lrate%g) \"\n \"CROSSVAL AVG.LOSS %.4f, TIME USED %.2f, %s\" % (\n epoch + 1, tr_loss, FLAGS.learning_rate, val_loss,\n used_time, \"nnet rejected\"))\n restore_from_ckpt(sess, saver)\n # Reducing learning rate.\n sess.run(reduce_learning_rate)\n\n # add a blank line for log readability\n print()\n sys.stdout.flush()","def train(self, lib, service, model_name, algorithm, dataset_url, label, train_percentage, features,\n save_model=True,\n params=None):\n url = self.base_url + '/ml-service/phoenix-ml/' + service + '/train'\n headers = {\"ApiKey\": self.api_key, \"Content-type\": \"application/json\"}\n if params is None:\n params = {}\n body = {\n \"library\": lib,\n \"task\": \"train\",\n \"config\": {\n \"name\": model_name,\n \"algorithm\": algorithm,\n \"datasetUrl\": dataset_url,\n \"label\": label,\n \"trainPercentage\": train_percentage,\n \"features\": features,\n \"saveModel\": save_model,\n \"params\": params\n }\n }\n response = requests.post(url=url, json=body, headers=headers)\n response = response.json()\n return response","def train(self):\n self.mode = \"train\"\n self.online_net.train()","def train(self):\n self.mode = \"train\"\n self.online_net.train()","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train_model(train: Train, tf: Featureset(\"transaction_features\")) -> Any:\n\n # We create the training and label data\n train_df = tf.to_pandas()\n X = train_df.drop([\"transactionId\", \"is_fraud\"], axis=1)\n Y = train_df[\"is_fraud\"]\n\n random_state = 13\n test_size = 0.2\n train.log_parameter(\"random_state\", random_state)\n train.log_parameter(\"test_size\", test_size)\n trainX, testX, trainY, testY = train_test_split(X, Y, test_size=test_size,\n random_state=random_state)\n\n # Here we register input & output of the train. Layer will use\n # this registers to extract the signature of the model and calculate\n # the drift\n train.register_input(trainX)\n train.register_output(trainY)\n\n max_depth = 3\n objective = 'binary:logitraw'\n train.log_parameter(\"max_depth\", max_depth)\n train.log_parameter(\"objective\", objective)\n\n # Train model\n param = {'max_depth': max_depth, 'objective': objective}\n dtrain = xgb.DMatrix(trainX, label=trainY)\n model_xg = xgb.train(param, dtrain)\n\n dtest = xgb.DMatrix(testX)\n preds = model_xg.predict(dtest)\n\n # Since the data is highly skewed, we will use the area under the\n # precision-recall curve (AUPRC) rather than the conventional area under\n # the receiver operating characteristic (AUROC). This is because the AUPRC\n # is more sensitive to differences between algorithms and their parameter\n # settings rather than the AUROC (see Davis and Goadrich,\n # 2006: http://pages.cs.wisc.edu/~jdavis/davisgoadrichcamera2.pdf)\n auprc = average_precision_score(testY, preds)\n train.log_metric(\"auprc\", auprc)\n\n # We return the model\n return model_xg","def train():\n args = arguments_st_train()\n\n h, w = map(int, args.input_size.split(','))\n input_size = (h, w)\n\n \n if args.use_random_seed:\n tf.set_random_seed(args.random_seed)\n \n # Create queue coordinator.\n coord = tf.train.Coordinator()\n \n # Load reader.\n with tf.name_scope(\"create_inputs\"):\n reader = ImageReader(\n args.data_dir,\n args.data_list,\n input_size=input_size,\n random_scale=args.random_scale,\n random_mirror=args.random_mirror,\n random_crop=args.random_crop,\n ignore_label=args.ignore_label,\n img_mean=IMG_MEAN,\n coord=coord,\n task=args.task)\n image_batch, label_batch = reader.dequeue(args.batch_size)\n \n # Create network.\n with slim.arg_scope(vgg_arg_scope(weight_decay=args.weight_decay, use_batch_norm=True, is_training=True)):\n if args.network == 'vgg_16_deeplab_st':\n net, end_points = vgg_16_deeplab_st(image_batch, num_classes=args.num_classes, is_training=True, dropout_keep_prob=args.keep_prob)\n elif args.network == 'vgg_16_shortcut_deeplab_st':\n net, end_points = vgg_16_shortcut_deeplab_st(image_batch, num_classes=args.num_classes, is_training=True, dropout_keep_prob=args.keep_prob)\n else:\n raise Exception('network name is not recognized!')\n \n \n # Predictions.\n raw_output = end_points['vgg_16/fc8_voc12']\n\n # gt labels\n raw_gt = prepare_label(label_batch, tf.stack(raw_output.get_shape()[1:3]), num_classes=args.num_classes,\n one_hot=False, task=args.task) # [batch_size, h, w]\n\n # losses\n if args.task == 'normal':\n loss = get_normal_loss(raw_output, raw_gt, args.num_classes, args.ignore_label) * args.loss_scale\n elif args.task == 'seg':\n loss = get_seg_loss(raw_output, raw_gt, args.num_classes, args.ignore_label) * args.loss_scale\n\n l2_losses = [args.weight_decay * tf.nn.l2_loss(v) for v in tf.trainable_variables() if 'weights' in v.name]\n reduced_loss = tf.reduce_mean(loss) + tf.add_n(l2_losses)\n \n # Image summary for visualisation.\n raw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\n raw_output_up = tf.argmax(raw_output_up, axis=3)\n pred = tf.expand_dims(raw_output_up, dim=3)\n \n images_summary = tf.py_func(inv_preprocess, [image_batch, args.save_num_images, IMG_MEAN], tf.uint8)\n labels_summary = tf.py_func(decode_labels, [label_batch, args.save_num_images, args.num_classes, args.task], tf.uint8)\n preds_summary = tf.py_func(decode_labels, [pred, args.save_num_images, args.num_classes, args.task], tf.uint8)\n \n total_summary = tf.summary.image('images', \n tf.concat(axis=2, values=[images_summary, labels_summary, preds_summary]), \n max_outputs=args.save_num_images) # Concatenate row-wise.\n summary_writer = tf.summary.FileWriter(args.snapshot_dir,\n graph=tf.get_default_graph())\n \n # Define loss and optimisation parameters.\n train_op, step_ph = create_train_ops_st(reduced_loss, args)\n \n # Set up tf session and initialize variables. \n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n init = tf.global_variables_initializer()\n \n sess.run(init)\n\n # Load variables if the checkpoint is provided.\n if args.restore_from is not None:\n load_st(sess, args)\n \n # Saver for storing checkpoints of the model.\n save_op = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=args.max_to_keep)\n \n # Start queue threads.\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\n\n # Iterate over training steps.\n for step in range(args.num_steps):\n start_time = time.time()\n feed_dict = { step_ph : step }\n \n if step % args.save_pred_every == 0:\n loss_value, images, labels, preds, summary, _ = sess.run([reduced_loss, image_batch, label_batch, pred, total_summary, train_op], feed_dict=feed_dict)\n summary_writer.add_summary(summary, step)\n save(save_op, sess, args.snapshot_dir, step)\n else:\n loss_value, _ = sess.run([reduced_loss, train_op], feed_dict=feed_dict)\n duration = time.time() - start_time\n print('step {:d} \\t loss = {:.3f}, ({:.3f} sec/step)'.format(step, loss_value, duration))\n coord.request_stop()\n coord.join(threads)","def train(self, train_set, model_tf, model_af, num_epochs=5, resume=False, dev_set=None):\n\n\t\ttorch.cuda.empty_cache()\n\t\tself.resume = resume\n\t\tif resume:\n\n\t\t\t# ------------------------------------------------------------------------------------\n\t\t\t# -------------------------- teacher forcing model resume ... \n\t\t\tlatest_checkpoint_path_tf = Checkpoint.get_latest_epoch_checkpoint(self.load_dir_tf)\n\t\t\tprint('resuming teacher forcing model {} ...'.format(latest_checkpoint_path_tf))\n\t\t\tresume_checkpoint_tf = Checkpoint.load(latest_checkpoint_path_tf)\n\t\t\tmodel_tf = resume_checkpoint_tf.model\n\t\t\tself.optimizer_tf = resume_checkpoint_tf.optimizer\n\n\t\t\t# check var\n\t\t\tmodel_tf.set_var('attention_forcing', False)\n\t\t\tmodel_tf.set_var('debug_count', 0)\n\t\t\tmodel_tf.reset_use_gpu(self.use_gpu)\n\t\t\tmodel_tf.to(device)\n\t\t\tprint('attention forcing: {}'.format(model_tf.attention_forcing))\n\t\t\tprint('use gpu: {}'.format(model_tf.use_gpu))\n\n\t\t\t# A walk around to set optimizing parameters properly\n\t\t\tresume_optim_tf = self.optimizer_tf.optimizer\n\t\t\tdefaults_tf = resume_optim_tf.param_groups[0]\n\t\t\tdefaults_tf.pop('params', None)\n\t\t\tdefaults_tf.pop('initial_lr', None)\n\t\t\tself.optimizer_tf.optimizer = resume_optim_tf.__class__(model_tf.parameters(), **defaults_tf)\n\n\t\t\t# ------------------------------------------------------------------------------------\n\t\t\t# ----------------------------- attention forcing model resume ... \n\t\t\tlatest_checkpoint_path_af = Checkpoint.get_latest_epoch_checkpoint(self.load_dir_af)\n\t\t\tprint('resuming attention forcing model {} ...'.format(latest_checkpoint_path_af))\n\t\t\tresume_checkpoint_af = Checkpoint.load(latest_checkpoint_path_af)\n\t\t\tmodel_af = resume_checkpoint_af.model\n\t\t\tself.optimizer_af = resume_checkpoint_af.optimizer\n\n\t\t\t# check var\n\t\t\tmodel_af.set_var('attention_forcing', True)\n\t\t\tmodel_af.set_var('debug_count', 0)\n\t\t\tmodel_af.reset_use_gpu(self.use_gpu)\n\t\t\tmodel_af.to(device)\n\t\t\tprint('attention forcing: {}'.format(model_af.attention_forcing))\n\t\t\tprint('use gpu: {}'.format(model_af.use_gpu))\n\n\t\t\t# A walk around to set optimizing parameters properly\n\t\t\tresume_optim_af = self.optimizer_af.optimizer\n\t\t\tdefaults_af = resume_optim_af.param_groups[0]\n\t\t\tdefaults_af.pop('params', None)\n\t\t\tdefaults_af.pop('initial_lr', None)\n\t\t\tself.optimizer_af.optimizer = resume_optim_af.__class__(model_af.parameters(), **defaults_af)\n\n\t\t\t# ------------------------------------------\n\t\t\tstart_epoch = resume_checkpoint_af.epoch\n\t\t\tstep = resume_checkpoint_af.step\n\n\t\telse:\n\t\t\tstart_epoch = 1\n\t\t\tstep = 0\n\n\t\t\tlog = self.logger.info(\"------ teacher forcing model ------ \")\n\t\t\tfor name, param in model_tf.named_parameters():\n\t\t\t\tlog = self.logger.info('{}:{}'.format(name, param.size()))\n\t\t\tlog = self.logger.info(\"------ attention forcing model ------ \")\n\t\t\tfor name, param in model_af.named_parameters():\n\t\t\t\tlog = self.logger.info('{}:{}'.format(name, param.size()))\n\t\t\t\t# check embedder init\n\t\t\t\t# if 'embedder' in name:\n\t\t\t\t# \tprint('{}:{}'.format(name, param[5]))\n\n\t\t\toptimizer_tf = Optimizer(torch.optim.Adam(model_tf.parameters(), \n\t\t\t\t\t\tlr=self.learning_rate), max_grad_norm=self.max_grad_norm) # 5 -> 1\n\t\t\toptimizer_af = Optimizer(torch.optim.Adam(model_af.parameters(), \n\t\t\t\t\t\tlr=self.learning_rate), max_grad_norm=self.max_grad_norm) # 5 -> 1\n\t\t\tself.optimizer_tf = optimizer_tf # teacher forcing\n\t\t\tself.optimizer_af = optimizer_af # attention forcing\n\n\t\tself.logger.info(\"TF Optimizer: %s, Scheduler: %s\" % (self.optimizer_tf.optimizer, self.optimizer_tf.scheduler))\n\t\tself.logger.info(\"AF Optimizer: %s, Scheduler: %s\" % (self.optimizer_af.optimizer, self.optimizer_af.scheduler))\n\n\t\tself._train_epoches(train_set, model_tf, model_af, num_epochs, start_epoch, step, dev_set=dev_set)\n\t\t\n\t\treturn model_tf, model_af","def trainNet():","def train(self, request):\n model = request.get(\"model\")\n if not model:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n \"Model is not provided for Training Task\",\n )\n\n task = self._trainers.get(model)\n if not task:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n f\"Train Task is not Initialized. There is no model '{model}' available\",\n )\n\n request = copy.deepcopy(request)\n result = task(request, self.datastore())\n\n # Run all scoring methods\n if self._auto_update_scoring:\n self.async_scoring(None)\n return result","def train(self, features, actions, rewards):\n self.model.fit(x=features, y=actions, sample_weight=rewards,\n verbose=False)","def train():\n # YOUR TRAINING CODE GOES HERE","def train(self, sess):\n assert self.mode == tf.contrib.learn.ModeKeys.TRAIN\n return sess.run([self.update,\n self.train_loss,\n self.global_step,\n self.train_summary])","def training(self):\n self.model.fit(self.train_x, self.train_y)","def train():\n with tf.Graph().as_default():\n global_step = tf.contrib.framework.get_or_create_global_step()\n\n # Get images and labels for ocr.\n print(\"Preparing input\")\n # with tf.device('/cpu:0'):\n images, labels, seq_lengths = ocr.distorted_inputs()\n\n # Build a Graph that computes the logits predictions from the\n # inference model.\n print(\"Building graph\")\n logits, timesteps = ocr.inference(images, FLAGS.batch_size, train=True)\n\n # Calculate loss.\n print(\"Creating loss\") \n loss = ocr.create_ctc_loss(logits, labels, timesteps, seq_lengths)\n\n print(\"Creating LER\")\n ler = ocr.create_label_error_rate(logits, labels, timesteps)\n\n print(\"Creating decoder\")\n decoded = ocr.check_decoder(logits, labels, timesteps)\n\n # Build a Graph that trains the model with one batch of examples and\n # updates the model parameters.\n print(\"Creating train OP\")\n train_op, lr = ocr.train_simple(loss, global_step)\n\n print(\"Creating init OP\")\n init_op = tf.group(tf.global_variables_initializer(),\n tf.local_variables_initializer())\n\n sess = tf.Session()\n\n sess.run(init_op)\n\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n \n train_writer = tf.summary.FileWriter(FLAGS.train_dir,\n sess.graph)\n saver = tf.train.Saver()\n summary_op = tf.summary.merge_all()\n\n print(\"Starting training\")\n print_every_n = 1000\n start_time = time.time()\n mean_ler = 0\n while not coord.should_stop():\n try: \n _, loss_res, lr_res, ler_res, summary_op_result, global_step_result, decoded_res = sess.run([train_op, loss, lr, ler, summary_op, global_step, decoded])\n mean_ler += ler_res\n if global_step_result % print_every_n == 0 or global_step_result == 1:\n mean_steps_time = (time.time() - start_time) / print_every_n\n mean_ler = mean_ler / print_every_n\n status_string = \"Step: {} Loss: {:.4f} LR: {:.6f} LER: {:.4f} Step time: {:.3f} sec\"\n print(status_string.format(global_step_result, loss_res, lr_res, ler_res, mean_steps_time)) \n # print(\"Decoded:\")\n # print(str(decoded_res))\n # print(\"Timesteps:\" + str(timesteps_res))\n train_writer.add_summary(summary_op_result, global_step=global_step_result)\n saver.save(sess, os.path.join(FLAGS.train_dir, 'checkpoint'), global_step=global_step)\n start_time = time.time()\n mean_ler = 0\n\n # images_res = sess.run(images)\n # print(images_res) \n # for img in images_res:\n # cv2.imshow(\"img\", img)\n # cv2.waitKey(0)\n except Exception as e:\n print(e)\n coord.request_stop(e)\n\n # class _LoggerHook(tf.train.SessionRunHook):\n # \"\"\"Logs loss and runtime.\"\"\"\n #\n # def begin(self):\n # self._step = -1\n #\n # def before_run(self, run_context):\n # self._step += 1\n # self._start_time = time.time()\n # return tf.train.SessionRunArgs(loss) # Asks for loss value.\n #\n # def after_run(self, run_context, run_values):\n # duration = time.time() - self._start_time\n # loss_value = run_values.results\n # if self._step % 10 == 0:\n # num_examples_per_step = FLAGS.batch_size\n # examples_per_sec = num_examples_per_step / duration\n # sec_per_batch = float(duration)\n #\n # format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '\n # 'sec/batch)')\n # print (format_str % (datetime.now(), self._step, loss_value,\n # examples_per_sec, sec_per_batch))\n #\n # with tf.train.MonitoredTrainingSession(\n # checkpoint_dir=FLAGS.train_dir,\n # hooks=[tf.train.StopAtStepHook(last_step=FLAGS.max_steps),\n # tf.train.NanTensorHook(loss),\n # _LoggerHook()],\n # config=tf.ConfigProto(\n # log_device_placement=FLAGS.log_device_placement)) as mon_sess:\n # while not mon_sess.should_stop():\n # print(\"Running session\")\n # mon_sess.run(train_op)","def build_train_model(hparams,\n scope=\"train\"):\n src_lang = hparams.src_lang\n src_vocab_file_name = hparams.src_vocab_file_name\n tgt_lang = hparams.tgt_lang\n tgt_vocab_file_name = hparams.tgt_vocab_file_name\n\n\n\n tf.reset_default_graph()\n\n train_graph = tf.Graph()\n with train_graph.as_default() as g:\n with tf.container(scope):\n src_vocab, tgt_vocab = load_vocabs(src_lang, src_vocab_file_name,\n tgt_lang, tgt_vocab_file_name)\n src_dataset_file_name = tf.placeholder(tf.string, name=\"src_dataset_file_name\")\n tgt_dataset_file_name = tf.placeholder(tf.string, name=\"tgt_dataset_file_name\")\n\n src_dataset = tf.data.TextLineDataset(src_dataset_file_name)\n tgt_dataset = tf.data.TextLineDataset(tgt_dataset_file_name)\n\n batch_size = tf.placeholder(tf.int64, name=\"batch_size\")\n\n # maximum sequence length for training example\n max_len = tf.placeholder(tf.int64, name=\"max_len\")\n\n iterator = Iterator(src_dataset, src_vocab,\n tgt_dataset, tgt_vocab, batch_size=batch_size, max_len=max_len)\n\n # actual TensorFlow Dataset Iterator\n iterator_tf = iterator.create_iterator()\n\n model_class = _get_model_from_str_type(hparams.model_name)\n\n model = model_class(hparams, src_vocab, tgt_vocab)\n\n model_graph = model.build_graph(iterator_tf,\n tf.contrib.learn.ModeKeys.TRAIN, batch_size, g)\n\n return NTModel(src_vocab=src_vocab,\n tgt_vocab=tgt_vocab,\n iterator_tf=iterator_tf,\n model_graph=model_graph,\n model=model,\n hparams=hparams,\n mode=tf.contrib.learn.ModeKeys.TRAIN)","def model_fn(features, labels, mode, params):\n # obtain the data\n _info('*** Features ***')\n for name in sorted(features.keys()):\n tf.logging.info(\" name = %s, shape = %s\" % (name, features[name].shape))\n\n input_ids = features['input_ids'] # [batch_size, seq_length]\n input_mask = features['input_mask'] # [batch_size, seq_length]\n\n # if mode != tf.estimator.ModeKeys.PREDICT:\n # # segment_idx = features['segment_dis']\n # masked_lm_positions = features['masked_lm_positions'] # [batch_size, seq_length], specify the answer\n # masked_lm_ids = features['masked_lm_ids'] # [batch_size, answer_seq_length], specify the answer labels\n # masked_lm_weights = features['masked_lm_weights'] # [batch_size, seq_length], [1, 1, 0], 0 refers to the mask\n # # next_sentence_labels = features['next_sentence_labels']\n # else:\n masked_lm_positions = features['masked_lm_positions']\n masked_lm_ids = features['masked_lm_ids']\n masked_lm_weights = features['masked_lm_weights']\n\n if bert_config.train_type == 'seq2seq':\n _info('Training seq2seq task.')\n elif bert_config.train_type == 'lm':\n _info('Training language model task.')\n \n # build model\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\n model = BertModel(\n config=bert_config,\n is_training=is_training,\n input_ids=input_ids,\n input_mask=input_mask)\n \n # compute loss\n loss, per_loss, log_probs, logits = get_masked_lm_output(bert_config,\n model.get_sequence_output(),\n model.embedding_table,\n model.projection_table,\n masked_lm_positions,\n masked_lm_ids,\n masked_lm_weights,\n mode)\n \n if mode == tf.estimator.ModeKeys.PREDICT:\n masked_lm_predictions = tf.reshape(tf.argmax(log_probs, axis=-1, output_type=tf.int32), [-1])\n output_spec = tf.estimator.EstimatorSpec(mode, predictions=masked_lm_predictions)\n else:\n if mode == tf.estimator.ModeKeys.TRAIN: \n # restore from the checkpoint,\n # tf.estimator automatically restore from the model typically,\n # maybe here is for restore some pre-trained parameters\n tvars = tf.trainable_variables()\n initialized_variable_names = {}\n if init_checkpoint:\n (assignment_map, initialized_variable_names) = get_assignment_map_from_checkpoint(tvars, init_checkpoint)\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n _info('*** Trainable Variables ***')\n for var in tvars:\n init_string = ''\n if var.name in initialized_variable_names:\n init_string = ', *INIT_FROM_CKPT*'\n _info('name = {}, shape={}{}'.format(var.name, var.shape, init_string))\n \n train_op = optimization.create_optimizer(\n loss, bert_config.learning_rate, num_train_steps, bert_config.lr_limit)\n\n # learning_rate = tf.train.polynomial_decay(bert_config.learning_rate,\n # tf.train.get_or_create_global_step(),\n # num_train_steps,\n # end_learning_rate=0.0,\n # power=1.0,\n # cycle=False)\n # optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)\n # gradients = tf.gradients(loss, tvars, colocate_gradients_with_ops=True)\n # clipped_gradients, _ = tf.clip_by_global_norm(gradients, 5.0)\n # train_op = optimizer.apply_gradients(zip(clipped_gradients, tvars), global_step=tf.train.get_global_step())\n output_spec = tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)\n elif mode == tf.estimator.ModeKeys.EVAL:\n is_real_example = tf.ones(tf.shape(masked_lm_ids), dtype=tf.float32)\n \n def metric_fn(loss, label_ids, logits, is_real_example):\n \"\"\"\n Args:\n loss: tf.float32.\n label_ids: [b, s].\n logits: [b, s, v].\n \"\"\"\n # [b * s, v]\n logits = tf.reshape(logits, [-1, logits.shape[-1]])\n # [b * s, 1]\n predictions = tf.argmax(logits, axis=-1, output_type=tf.int32)\n # [b * s]\n label_ids = tf.reshape(label_ids, [-1])\n accuracy = tf.metrics.accuracy(\n labels=label_ids, predictions=predictions)\n loss = tf.metrics.mean(values=loss)\n return {'eval_accuracy': accuracy, 'eval_loss': loss}\n \n eval_metrics = metric_fn(loss, masked_lm_ids, logits, is_real_example)\n output_spec = tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metrics)\n\n return output_spec","def train(args):\n \n\n train_generator, validation_generator, num_training, num_validation, num_classes = generate(args)\n print(\"{} classes found\".format(num_classes))\n\n model = MobileNetV2((args.input_size, args.input_size, 3), num_classes, args.plot_model)\n\n opt = tf.keras.optimizers.Adam()\n earlystop = tf.keras.callbacks.EarlyStopping(monitor='val_acc', patience=30, verbose=1, mode='auto')\n model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['acc'])\n\n hist = model.fit_generator(\n train_generator,\n validation_data=validation_generator,\n steps_per_epoch=num_training // args.batch_size,\n validation_steps=num_validation // args.batch_size,\n epochs=args.epochs,\n callbacks=[earlystop])\n\n if not os.path.exists('model'):\n os.makedirs('model')\n\n df = pd.DataFrame.from_dict(hist.history)\n df.to_csv('model/hist.csv', encoding='utf-8', index=False)\n if not os.path.exists('model/output'):\n os.makedirs('model/output')\n model.save('model/output')","def train(self, dataset, model_dir):\n raise NotImplementedError","def train(log_dir):\n\n # Create train and test environments\n print(\n colorize(\n f\"INFO: You are training in the {ENV_NAME} environment.\",\n \"cyan\",\n bold=True,\n )\n )\n env = get_env_from_name(ENV_NAME, ENV_SEED)\n test_env = get_env_from_name(ENV_NAME, ENV_SEED)\n\n # Set initial learning rates\n lr_a, lr_l, lr_c = (\n ALG_PARAMS[\"lr_a\"],\n ALG_PARAMS[\"lr_l\"],\n ALG_PARAMS[\"lr_c\"],\n )\n lr_a_now = ALG_PARAMS[\"lr_a\"] # learning rate for actor, lambda and alpha\n lr_l_now = ALG_PARAMS[\"lr_l\"] # learning rate for Lyapunov critic\n lr_c_now = ALG_PARAMS[\"lr_c\"] # learning rate for q critic\n\n # Get observation and action space dimension and limits from the environment\n s_dim = env.observation_space.shape[0]\n a_dim = env.action_space.shape[0]\n a_lowerbound = env.action_space.low\n a_upperbound = env.action_space.high\n\n # Create the Agent\n policy = LAC(a_dim, s_dim, act_limits={\"low\": a_lowerbound, \"high\": a_upperbound})\n\n # Load model if retraining is selected\n if TRAIN_PARAMS[\"continue_training\"]:\n\n # Create retrain model path\n retrain_model_folder = TRAIN_PARAMS[\"continue_model_folder\"]\n retrain_model_path = osp.abspath(\n osp.join(log_dir, \"../..\", TRAIN_PARAMS[\"continue_model_folder\"])\n )\n\n # Check if retrain model exists if not throw error\n if not osp.exists(retrain_model_path):\n print(\n colorize(\n (\n \"ERROR: Shutting down training since the model you specified \"\n f\"in the `continue_model_folder` `{retrain_model_folder}` \"\n f\"argument was not found for the `{ENV_NAME}` environment.\"\n ),\n \"red\",\n bold=True,\n )\n )\n sys.exit(0)\n\n # Load old model\n print(\n colorize(\n f\"INFO: Restoring model `{retrain_model_path}`.\", \"cyan\", bold=True\n )\n )\n result = policy.restore(\n osp.abspath(osp.join(retrain_model_path, \"policy\")),\n restore_lagrance_multipliers=(not ALG_PARAMS[\"reset_lagrance_multipliers\"]),\n )\n if not result:\n print(\n colorize(\n \"ERROR: Shuting down training as something went wrong while \"\n \"loading \"\n f\"model `{retrain_model_folder}`.\",\n \"red\",\n bold=True,\n )\n )\n sys.exit(0)\n\n # Create new storage folder\n log_dir_split = log_dir.split(\"/\")\n log_dir_split[-2] = (\n \"_\".join(TRAIN_PARAMS[\"continue_model_folder\"].split(\"/\")) + \"_finetune\"\n )\n log_dir = \"/\".join(log_dir_split)\n else:\n print(colorize(f\"INFO: Train new model `{log_dir}`\", \"cyan\", bold=True))\n\n # Print logging folder path\n print(colorize(f\"INFO: Logging results to `{log_dir}`.\", \"cyan\", bold=True))\n\n # Create replay memory buffer\n pool = Pool(\n s_dim=s_dim,\n a_dim=a_dim,\n store_last_n_paths=TRAIN_PARAMS[\"num_of_training_paths\"],\n memory_capacity=ALG_PARAMS[\"memory_capacity\"],\n min_memory_size=ALG_PARAMS[\"min_memory_size\"],\n )\n\n # Setup logger and log hyperparameters\n logger.configure(dir=log_dir, format_strs=[\"csv\"])\n logger.logkv(\"tau\", ALG_PARAMS[\"tau\"])\n logger.logkv(\"alpha3\", ALG_PARAMS[\"alpha3\"])\n logger.logkv(\"batch_size\", ALG_PARAMS[\"batch_size\"])\n logger.logkv(\"target_entropy\", policy.target_entropy)\n\n ####################################################\n # Training loop ####################################\n ####################################################\n\n # Setup training loop parameters\n t1 = time.time()\n global_step = 0\n global_episodes = 0\n last_training_paths = deque(maxlen=TRAIN_PARAMS[\"num_of_training_paths\"])\n training_started = False\n\n # Train the agent in the environment until max_episodes has been reached\n print(colorize(\"INFO: Training...\\n\", \"cyan\", bold=True))\n while 1: # Keep running episodes until global step has been reached\n\n # Create variable to store information about the current path\n if policy.use_lyapunov:\n current_path = {\n \"rewards\": [],\n \"lyapunov_error\": [],\n \"alpha\": [],\n \"lambda\": [],\n \"entropy\": [],\n \"a_loss\": [],\n \"alpha_loss\": [],\n \"lambda_loss\": [],\n }\n else:\n current_path = {\n \"rewards\": [],\n \"critic_error\": [],\n \"alpha\": [],\n \"entropy\": [],\n \"a_loss\": [],\n \"alpha_loss\": [],\n }\n\n # Reset environment\n s = env.reset()\n\n # Training Episode loop\n for jj in range(ENVS_PARAMS[ENV_NAME][\"max_ep_steps\"]):\n\n # Break out of loop if global steps have been reached\n if global_step >= TRAIN_PARAMS[\"max_global_steps\"]:\n\n # Print step count, save model and stop the program\n print(\n colorize(\n f\"\\nINFO: Training stopped after {global_step} steps.\",\n \"cyan\",\n bold=True,\n )\n )\n print(\n colorize(\n \"INFO: Running time: {}\".format(time.time() - t1),\n \"cyan\",\n bold=True,\n )\n )\n print(colorize(\"INFO: Saving Model\", \"cyan\", bold=True))\n policy.save_result(log_dir)\n return\n\n # Save intermediate checkpoints if requested\n if TRAIN_PARAMS[\"save_checkpoints\"]:\n if (\n global_step % TRAIN_PARAMS[\"checkpoint_save_freq\"] == 0\n and global_step != 0\n ):\n\n # Create intermediate result checkpoint folder\n checkpoint_save_path = osp.abspath(\n osp.join(log_dir, \"checkpoints\", \"step_\" + str(jj))\n )\n os.makedirs(checkpoint_save_path, exist_ok=True)\n\n # Save intermediate checkpoint\n policy.save_result(checkpoint_save_path)\n\n # Render environment if requested\n if ENVS_PARAMS[ENV_NAME][\"eval_render\"]:\n env.render()\n\n # Retrieve (scaled) action based on the current policy\n # NOTE (rickstaa): The scaling operation is already performed inside the\n # policy based on the `act_limits` you supplied.\n a = policy.choose_action(s)\n\n # Perform action in env\n s_, r, done, _ = env.step(a)\n\n # Increment global step count\n if training_started:\n global_step += 1\n\n # Stop episode if max_steps has been reached\n if jj == ENVS_PARAMS[ENV_NAME][\"max_ep_steps\"] - 1:\n done = True\n terminal = 1.0 if done else 0.0\n\n # Store experience in replay buffer\n pool.store(s, a, r, terminal, s_)\n\n # Optimize network weights and lagrance multipliers\n if (\n pool.memory_pointer > ALG_PARAMS[\"min_memory_size\"]\n and global_step % ALG_PARAMS[\"steps_per_cycle\"] == 0\n ):\n training_started = True\n\n # Perform STG a set number of times (train per cycle)\n for _ in range(ALG_PARAMS[\"train_per_cycle\"]):\n batch = pool.sample(ALG_PARAMS[\"batch_size\"])\n if policy.use_lyapunov:\n (\n labda,\n alpha,\n l_loss,\n entropy,\n a_loss,\n alpha_loss,\n labda_loss,\n ) = policy.learn(lr_a_now, lr_l_now, lr_a, lr_c_now, batch)\n else:\n alpha, loss_q, entropy, a_loss, alpha_loss = policy.learn(\n lr_a_now, lr_l_now, lr_a, lr_c_now, batch\n )\n\n # Store current path results\n if training_started:\n if policy.use_lyapunov:\n current_path[\"rewards\"].append(r)\n current_path[\"lyapunov_error\"].append(l_loss)\n current_path[\"alpha\"].append(alpha)\n current_path[\"lambda\"].append(labda)\n current_path[\"entropy\"].append(entropy)\n current_path[\"a_loss\"].append(a_loss)\n current_path[\"alpha_loss\"].append(alpha_loss)\n current_path[\"lambda_loss\"].append(labda_loss)\n else:\n current_path[\"rewards\"].append(r)\n current_path[\"critic_error\"].append(loss_q.numpy())\n current_path[\"alpha\"].append(alpha.numpy())\n current_path[\"entropy\"].append(entropy.numpy())\n current_path[\"a_loss\"].append(\n a_loss.numpy()\n ) # Improve: Check if this is the fastest way\n current_path[\"alpha_loss\"].append(alpha_loss)\n\n # Evalute the current policy performance and log the results\n if (\n training_started\n and global_step % TRAIN_PARAMS[\"evaluation_frequency\"] == 0\n and global_step > 0\n ):\n logger.logkv(\"total_timesteps\", global_step)\n training_diagnostics = evaluate_training_rollouts(last_training_paths)\n if training_diagnostics is not None:\n if TRAIN_PARAMS[\"num_of_evaluation_paths\"] > 0:\n eval_diagnostics = training_evaluation(test_env, policy)\n [\n logger.logkv(key, eval_diagnostics[key])\n for key in eval_diagnostics.keys()\n ]\n training_diagnostics.pop(\"return\")\n [\n logger.logkv(key, training_diagnostics[key])\n for key in training_diagnostics.keys()\n ]\n logger.logkv(\"lr_a\", lr_a_now)\n if policy.use_lyapunov:\n logger.logkv(\"lr_l\", lr_l_now)\n else:\n logger.logkv(\"lr_c\", lr_c_now)\n string_to_print = [\"time_step:\", str(global_step), \"|\"]\n if TRAIN_PARAMS[\"num_of_evaluation_paths\"] > 0:\n [\n string_to_print.extend(\n [key, \":\", str(eval_diagnostics[key]), \"|\"]\n )\n for key in eval_diagnostics.keys()\n ]\n [\n string_to_print.extend(\n [key, \":\", str(round(training_diagnostics[key], 2)), \"|\"]\n )\n for key in training_diagnostics.keys()\n ]\n prefix = (\n colorize(\"LAC|\", \"green\")\n if ALG_PARAMS[\"use_lyapunov\"]\n else colorize(\"SAC|\", \"yellow\")\n )\n print(\n colorize(prefix, \"yellow\", bold=True) + \"\".join(string_to_print)\n )\n logger.dumpkvs()\n\n # Update state\n s = s_\n\n # Check if episode is done (continue to next episode)\n if done:\n\n # Store paths\n if training_started:\n last_training_paths.appendleft(current_path)\n\n # Decay learning rates\n frac = 1.0 - (global_step - 1.0) / TRAIN_PARAMS[\"max_global_steps\"]\n lr_a_now = lr_a * frac # learning rate for actor, lambda, alpha\n lr_l_now = lr_l * frac # learning rate for Lyapunov critic\n lr_c_now = lr_c * frac # learning rate for q critic\n break # Continue to next episode\n\n # Increase episode counter\n global_episodes += 1","def train(self):\n # setup model\n self.createModel()\n self.setGenerators()\n self.buildCallbacks()\n self.printParameters()\n \n # train model\n _ = self.model.fit_generator(\n generator = self.trainGen,\n validation_data = self.validateGen,\n steps_per_epoch = self.steps_per_epoch,\n validation_steps = self.validation_steps,\n epochs = self.epochs,\n use_multiprocessing = True,\n callbacks = self.callbacks)\n # clear save paths to avoid overwriting accidentaly\n self.saveName = None","def train(self, args):\n\n ##################################\n # Read the training data\n ##################################\n if not os.path.isdir(args.annotationPath):\n print('annotation path does not exist: {}' \\\n .format(args.annotationPath))\n return -1\n\n data = self.readData(args.annotationPath)\n\n x = []\n y = []\n l = []\n for subject, df in data.items():\n lx = df[['gradient', 'rate']].values.tolist()\n ly = np.array(df[['immersion']].values.tolist()).squeeze(-1)\n x.extend(lx)\n y.extend(ly.tolist())\n l.append(len(lx))\n\n ############################\n # Execute the training\n ############################\n\n print('Training the detector...')\n self._clf.fit(x, y, l)\n\n if not self.save():\n print('Could not persist the trained model to disk (in file {})' \\\n .format(self._modelFile))\n\n return 0","def train(self, training_steps=10):","def sentiment(dash_comment):\n\n label_list = [0,1]# Label categories\n max_seq_length = 128# maximum length of (token) input sequences\n train_batch_size = 32\n\n\n # Get BERT layer and tokenizer:\n # More details here: https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/4\n\n bert_layer = hub.KerasLayer('https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/2', trainable=True)\n\n vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()\n do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()\n tokenizer = tokenization.FullTokenizer(vocab_file,do_lower_case)\n\n def to_feature(text, label, label_list=label_list, max_seq_length=max_seq_length, tokenizer=tokenizer):\n example = classifier_data_lib.InputExample(guid=None,\n text_a = text.numpy(),\n text_b = None,\n label = label.numpy())\n feature = classifier_data_lib.convert_single_example(0,example, label_list,max_seq_length,tokenizer)\n\n return (feature.input_ids, feature.input_mask, feature.segment_ids, feature.label_id)\n\n def to_feature_map(text, label):\n input_ids, input_mask, segment_ids, label_id = tf.py_function(to_feature, inp=[text, label],\n Tout = [tf.int32,tf.int32,tf.int32,tf.int32])\n input_ids.set_shape([max_seq_length])\n input_mask.set_shape([max_seq_length])\n segment_ids.set_shape([max_seq_length])\n label_id.set_shape([])\n\n x = {\n 'input_word_ids': input_ids,\n 'input_mask': input_mask,\n 'input_type_ids': segment_ids\n }\n\n return (x, label_id)\n\n def create_model():\n input_word_ids = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\n name=\"input_word_ids\")\n input_mask = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\n name=\"input_mask\")\n input_type_ids = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\n name=\"input_type_ids\")\n pooled_output, sequence_output = bert_layer([input_word_ids, input_mask, input_type_ids])\n\n drop = tf.keras.layers.Dropout(0.4)(pooled_output)\n output = tf.keras.layers.Dense(1, activation='sigmoid', name='output')(drop)\n\n model = tf.keras.Model(\n inputs={\n 'input_word_ids': input_word_ids,\n 'input_mask': input_mask,\n 'input_type_ids': input_type_ids\n\n },\n outputs=output\n )\n return model\n\n def sentiment_classifier(list):\n return max(set(list), key=list.count)\n # right_test = pd.read_csv('/Users/steve/Google Drive/Dissertation/newtestconservative.csv', usecols=[1,2,3,4,5])\n # left_test = pd.read_csv('/Users/steve/Google Drive/Dissertation/newtestliberal.csv', usecols=[1,2,3,4,5])\n # test_df = pd.concat([right_test, left_test])\n # test_df.columns = ['Comment', 'Date','Score','Subreddit','Label']\n # test_df['Label'] = test_df['Label'].map({'Right-Wing':1, 'Left-Wing':0})\n # test_df.Comment = test_df.Comment.astype(str)\n\n model = create_model()\n model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=2e-5),\n loss = tf.keras.losses.BinaryCrossentropy(),\n metrics = [tf.keras.metrics.BinaryAccuracy()])\n model.summary()\n\n print('Model loading')\n model.load_weights('new_model_all_data_5epochs').expect_partial()\n print('Model loaded')\n sample_example = []\n sample_example.append(dash_comment)\n # # sample_example = ['Trump goes ahead with plans to build wall at the border of Mexico',\n # # 'Brexit',\n # # 'The EU is stealing our jobs',\n # # 'Rep. Marjorie Taylor Greene has been suspended from tweeting for a week after she claimed on Twitter yesterday that vaccines are “failing.”',\n # # 'All Rabbits should be placed on birth control. The cost of babies is ruining our democracy.',\n # # 'Journalism is dead.',\n # # 'fuck the tories',\n # # 'I Love Joe Biden',\n # # 'Boris Johnson is a responsible for brexit'\n # ]\n\n test_data = tf.data.Dataset.from_tensor_slices((sample_example, [0]*len(sample_example)))\n test_data = (test_data.map(to_feature_map).batch(1))\n print('predicting')\n preds=model.predict(test_data, verbose=1)\n threshold = 0.5\n result = [1 if pred >= threshold else 0 for pred in preds]\n results = []\n for i in preds:\n if i <=0.25:\n results.append('Strongly Left-wing')\n elif i >= 0.25 and i < 0.40:\n results.append('Somewhat Left-wing')\n elif i >= 0.40 and i < 0.50:\n results. append('Slightly Left-wing')\n elif i == 0.5:\n results.append('Neutral')\n elif i >= 0.5 and i < 0.60:\n results.append('Slightly Right-wing')\n elif i >= 0.60 and i < 0.75:\n results. append('Somewhat Right-wing')\n elif i >= 0.75:\n results.append('Strongly Right-wing')\n\n return \"{scr}\".format(scr=sentiment_classifier(results))\n # y_true = [1,1,1,0,1,1,0,0,0]\n # report = classification_report(y_true, result)\n # print(report)\n # print(results)","def train(self, batch):\n pass","def main_modeling_pipeline():\n\n\n data_df = pd.read_csv('gs://aiplatformfilipegracio2020/head_train_data.csv')\n data_df = data_df[[LABEL, 'price', 'days_on_site']]\n\n class_weights = calculate_class_weights(data_df[LABEL])\n print('class weights', class_weights)\n logging.info('Data loaded and processed')\n train_ds, val_ds, test_ds = make_tf_datasets(data_df, LABEL)\n logging.info('Tensorflow datasets created')\n\n with strategy.scope():\n logging.info('Inside strategy')\n simple_feature_layer = make_simple_feature_layer(data_df)\n logging.info('Going to make model')\n simple_model = make_simple_model(simple_feature_layer)\n\n logging.info('Going fit model')\n simple_model_results, simple_model = model_fit_and_evaluate(model=simple_model,\n train_ds=train_ds,\n val_ds=val_ds,\n test_ds=test_ds,\n class_weights=class_weights,\n epochs=TRAINING_EPOCHS,\n job_name='simple_model')\n\n simple_model.save('gs://aiplatformfilipegracio2020/')","def initiate(self):\n # if self.opt.checkpoint_encoder:\n # self.load(self.opt.checkpoint_encoder, self.opt.checkpoint_decoder)\n # else:\n # start fresh.\n self.model = Transformer(\n self.opt.src_vocab_size,\n self.opt.tgt_vocab_size,\n self.opt.max_token_seq_len,\n tgt_emb_prj_weight_sharing=self.opt.proj_share_weight,\n emb_src_tgt_weight_sharing=self.opt.embs_share_weight,\n d_k=self.opt.d_k,\n d_v=self.opt.d_v,\n d_model=self.opt.d_model,\n d_word_vec=self.opt.d_word_vec,\n d_inner=self.opt.d_inner_hid,\n n_layers=self.opt.layers,\n n_head=self.opt.n_head,\n dropout=self.opt.dropout).to(self.device)\n \n for p in self.model.parameters():\n if p.dim() > 1:\n nn.init.xavier_uniform_(p)","def train(self):\n self.ae_train(self.net0, self.ae0_optimizer, self.train0_loader, self.val_loader, name='Net0')\n self.ae_train(self.net1, self.ae1_optimizer, self.train1_loader, self.val_loader, name='Net1')\n self.ae_train(self.net2, self.ae2_optimizer, self.train2_loader, self.val_loader, name='Net2')\n\n self.classifier_train(self.net0, self.optimizer0, self.train0_loader, self.val_loader, name='Net0')\n self.classifier_train(self.net1, self.optimizer1, self.train1_loader, self.val_loader, name='Net1')\n self.classifier_train(self.net2, self.optimizer2, self.train2_loader, self.val_loader, name='Net2')","def train(self, session, train_examples, dev_examples, train_dir):\n\n # some free code to print out number of parameters in your model\n # it's always good to check!\n # you will also want to save your model parameters in train_dir\n # so that you can use your trained model to make predictions, or\n # even continue training\n\n tic = time.time()\n params = tf.trainable_variables()\n num_params = sum(map(lambda t: np.prod(tf.shape(t.value()).eval()), params))\n toc = time.time()\n logging.info(\"Number of params: %d (retreival took %f secs)\" % (num_params, toc - tic))\n\n if self.summary_flag:\n self.train_writer = tf.summary.FileWriter(self.summaries_dir + '/train', session.graph)\n\n logging.info(\"Train Loss File: {}\".format(self.train_loss_log))\n logging.info(\"Dev Loss File: {}\".format(self.dev_loss_log))\n best_score = 100000\n train_log = open(self.train_loss_log, \"w\")\n dev_log = open(self.dev_loss_log, \"w\")\n for epoch in range(self.n_epoch):\n print(\"Epoch {:} out of {:}\".format(epoch + 1, self.n_epoch))\n dev_score = self.run_epoch(session, train_examples, dev_examples, epoch, train_log)\n dev_log.write(\"{},{}\\n\".format(epoch + 1, dev_score))\n logging.info(\"Average Dev Cost: {}\".format(dev_score))\n logging.info(\"train F1 & EM\")\n f1, em = self.evaluate_answer(session, train_examples, self.rev_vocab, log = True)\n logging.info(\"Dev F1 & EM\")\n f1, em = self.evaluate_answer(session, dev_examples, self.rev_vocab, log = True)\n if dev_score < best_score:\n best_score = dev_score\n print(\"New best dev score! Saving model in {}\".format(train_dir + \"/\" + self.model_name))\n self.saver.save(session, train_dir + \"/\" + self.model_name)\n\n return best_score","def train():\n \n ## check for request data\n if not request.json:\n print(\"ERROR: API (train): did not receive request data\")\n return jsonify(False)\n\n ## set the test flag\n test = False\n if 'mode' in request.json and request.json['mode'] == 'test':\n test = True\n\n print(\"... training model\")\n model = model_train(test=test)\n print(\"... training complete\")\n\n return(jsonify(True))","def train(self):\n backend = self.config.backend.build(self.config, self.tmp_dir)\n backend.train(source_bundle_uri=self.config.source_bundle_uri)","def train(articles, force_create=False):\n global _trained\n # Setup\n bag_of_words.train(articles, force_create)\n term_frequency.train(articles, force_create)\n _get_idfs(articles)\n _trained = True\n for article in articles:\n get_vector(article, force_create, True)","def main():\n # Read data for train set\n print('loading training data')\n train = read_datafile('../data/tsd_train.csv')\n\n # Read trial data for validation set\n validation = read_datafile('../data/tsd_trial.csv')\n\n # Read data for test set\n print('loading test data')\n test = read_datafile('../data/tsd_test.csv')\n\n # Convert training data to Spacy Entities\n nlp = spacy.load(\"en_core_web_sm\")\n print('preparing training data')\n training_data = []\n for n, (spans, text) in enumerate(train):\n doc = nlp(text)\n ents = spans_to_ents(doc, set(spans), 'TOXIC')\n training_data.append((doc.text, {'entities': ents}))\n\n toxic_tagging = spacy.blank('en')\n toxic_tagging.vocab.strings.add('TOXIC')\n ner = nlp.create_pipe(\"ner\")\n toxic_tagging.add_pipe(ner, last=True)\n ner.add_label('TOXIC')\n\n pipe_exceptions = [\"ner\", \"trf_wordpiecer\", \"trf_tok2vec\"]\n unaffected_pipes = [\n pipe for pipe in toxic_tagging.pipe_names\n if pipe not in pipe_exceptions]\n\n\n print('Training!')\n with toxic_tagging.disable_pipes(*unaffected_pipes):\n \n toxic_tagging.begin_training()\n for iteration in range(30):\n random.shuffle(training_data)\n losses = {}\n batches = spacy.util.minibatch(\n training_data, size=spacy.util.compounding(\n 4.0, 32.0, 1.001))\n for batch in batches:\n texts, annotations = zip(*batch)\n toxic_tagging.update(texts, annotations, drop=0.5, losses=losses)\n print(\"Losses\", losses)\n\n\n # Define helper function for evaluating datasets\n def evaluate(dateset):\n precision_recall_f1_scores = []\n for spans, text in dateset:\n pred_spans = []\n doc = toxic_tagging(text)\n for ent in doc.ents:\n pred_spans.extend(range(ent.start_char, ent.start_char + len(ent.text)))\n \n # score = semeval2021.f1(pred_spans, spans)\n precision_recall_f1_scores.append(per_post_precision_recall_f1(pred_spans, spans))\n\n # compute average precision, recall and f1 score of all posts\n return np.array(precision_recall_f1_scores).mean(axis=0)\n\n # Evaluate on dev and test sets\n print('Evaluation:')\n eval_precision, eval_recall, eval_f1 = evaluate(validation)\n test_precision, test_recall, test_f1 = evaluate(test)\n \n print(f'Dev set: Precision = {eval_precision}, Recall = {eval_recall}, F1 = {eval_f1}')\n print(f'Test set: Precision = {test_precision}, Recall = {test_recall}, F1 = {test_f1}')","def train_model(args: argparse.Namespace, hp: HParams, extension_architecture: str, timestamp: str,\n logger: logging.Logger) -> None:\n # 1. Check if we have to train a single tier or a complete model (with several tiers)\n if args.tier is not None:\n # 1.1 Argument tier was defined. Only that tier will be trained.\n logging.info(f\"Training single tier of the model: Tier {args.tier}\")\n\n # 2. Setup tensorboard logging\n # 2.1 Create tensorboard logs directory (tensorboard requires a different folder for each\n # run of the model, in this case every run to train a tier) so we add the extension of the\n # network's architecture of this run and the timestamp to identify it completely\n tensorboard_dir = f\"{hp.logging.dir_log_tensorboard}{extension_architecture}_\" \\\n f\"{timestamp}_tier{args.tier}\"\n Path(tensorboard_dir).mkdir(parents=True, exist_ok=True)\n # 2.2 Create tensorboard writer\n tensorboardwriter = TensorboardWriter(hp, tensorboard_dir)\n\n # 3. Start training of the tier\n train_tier(args, hp, args.tier, extension_architecture, timestamp, tensorboardwriter,\n logger)\n\n tensorboardwriter.close()\n\n else:\n # 1.2 Argument tier was not defined. Train all tiers of the model.\n logging.info(\"Training all tiers of the model\")\n\n for tier in range(1, hp.network.n_tiers + 1):\n # 2. Setup tensorboard logging (one for every tier)\n # 2.1 Create tensorboard logs directory (tensorboard requires a different folder for\n # each run of the model, in this case every run to train a tier) so we add the extension\n # of the network's architecture of this run and the timestamp to identify it completely\n tensorboard_dir = hp.logging.dir_log_tensorboard + extension_architecture \\\n + f\"_{timestamp}_tier{tier}\"\n Path(tensorboard_dir).mkdir(parents=True, exist_ok=True)\n # 2.2 Create tensorboard writer\n tensorboardwriter = TensorboardWriter(hp, tensorboard_dir)\n\n # 3. Start training of the tier\n train_tier(args, hp, tier, extension_architecture, timestamp, tensorboardwriter, logger)\n\n tensorboardwriter.close()\n del tensorboardwriter","def train(self, training_data: TrainingData, config: RasaNLUModelConfig, **kwargs: Any) -> None:\n pass","def inc_train(self, conf):\n conf['angel.worker.matrix.transfer.request.timeout.ms'] = 60000\n conf[AngelConf.ANGEL_TASK_USER_TASKCLASS] = 'com.tencent.angel.ml.regression.linear.LinearRegTrainTask'\n\n # Create an angel job client\n client = AngelClientFactory.get(conf)\n\n # Submit this application\n client.startPSServer()\n\n # Create a model\n model = conf._jvm.com.tencent.angel.ml.regression.linear.LinearRegModel(conf._jconf)\n\n # Load model meta to client\n client.loadModel(model)\n\n # Run user task\n client.runTask('com.tencent.angel.ml.regression.linear.LinearRegTrainTask')\n\n # Wait for completion,\n # User task is set in AngelConf.ANGEL_TASK_USER_TASKCLASS\n client.waitForCompletion()\n\n # Save the incremental trained model to HDFS\n client.saveModel(model)\n\n # Stop\n client.stop()","def set_train(self):\n self.model.train()","def train_model(\n fname: Path,\n save_name: Path,\n batch_size: int = 32,\n warmup_steps: int = 100,\n steps: int = 1000,\n num_heads: int = 2,\n model_dim: int = 128,\n key_dim: int = 128,\n value_dim: int = 128,\n dropout: float = 0.1,\n num_mask: int = 9,\n):\n seqs = read_fasta(fname)\n\n X = seqs_to_integer(seqs)\n\n X = torch.from_numpy(X).type(torch.LongTensor)\n\n X_train, X_test = random_split(X)\n\n train_params = {\n \"batch_size\": batch_size,\n \"lr\": 0.0005,\n \"weight_decay\": 0.0,\n \"warmup_steps\": warmup_steps,\n \"steps\": steps,\n }\n model_params[\"n_head\"] = num_heads\n model_params[\"d_model\"] = model_dim\n model_params[\"d_k\"] = key_dim\n model_params[\"d_v\"] = value_dim\n model_params[\"dropout\"] = dropout\n model_params[\"num_mask\"] = num_mask\n\n model = BERT(**model_params)\n\n optimizer = Adam(\n model.parameters(),\n lr=train_params[\"lr\"],\n weight_decay=train_params[\"weight_decay\"],\n )\n\n scheduler = WarmupAnnealLR(optimizer, warmup_steps=train_params[\"warmup_steps\"])\n\n train(\n model,\n X_train,\n X_test,\n save_name,\n batch_size=train_params[\"batch_size\"],\n optimizer=optimizer,\n scheduler=scheduler,\n steps=train_params[\"steps\"],\n pbar_increment=10,\n )","def model_fn(features, labels, mode, params): # pylint: disable=unused-argument\n\n # tf.logging.info(\"*** Features ***\")\n # for name in sorted(features.keys()):\n # tf.logging.info(\" name = %s, shape = %s\" % (name, features[name].shape))\n\n input_ids = features[\"input_ids\"]\n input_mask = features[\"input_mask\"]\n segment_ids = features[\"segment_ids\"]\n label_ids = features[\"label_ids\"]\n is_real_example = None\n if \"is_real_example\" in features:\n is_real_example = tf.cast(features[\"is_real_example\"], dtype=tf.float32)\n else:\n is_real_example = tf.ones(tf.shape(label_ids), dtype=tf.float32)\n\n is_training = mode == tf.estimator.ModeKeys.TRAIN\n\n model = modeling.BertModel(\n config=bert_config,\n is_training=is_training,\n input_ids=input_ids,\n input_mask=input_mask,\n token_type_ids=segment_ids,\n use_one_hot_embeddings=use_one_hot_embeddings,\n )\n\n tvars = tf.trainable_variables()\n initialized_variable_names = {}\n scaffold_fn = None\n if init_checkpoint:\n (\n assignment_map,\n initialized_variable_names,\n ) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\n if use_tpu:\n\n def tpu_scaffold():\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n return tf.train.Scaffold()\n\n scaffold_fn = tpu_scaffold\n else:\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n tf.logging.info(\"**** Trainable Variables ****\")\n for var in tvars:\n init_string = \"\"\n if var.name in initialized_variable_names:\n init_string = \", *INIT_FROM_CKPT*\"\n\n output_spec = None\n if mode == tf.estimator.ModeKeys.TRAIN:\n\n train_op = optimization.create_optimizer(\n total_loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu\n )\n\n output_spec = tf.estimator.EstimatorSpec(\n mode=mode, loss=total_loss, train_op=train_op, scaffold=scaffold_fn\n )\n elif mode == tf.estimator.ModeKeys.EVAL:\n\n def metric_fn(per_example_loss, label_ids, probabilities, is_real_example):\n\n logits_split = tf.split(probabilities, num_labels, axis=-1)\n label_ids_split = tf.split(label_ids, num_labels, axis=-1)\n # metrics change to auc of every class\n eval_dict = {}\n for j, logits in enumerate(logits_split):\n label_id_ = tf.cast(label_ids_split[j], dtype=tf.int32)\n current_auc, update_op_auc = tf.metrics.auc(label_id_, logits)\n eval_dict[str(j)] = (current_auc, update_op_auc)\n eval_dict[\"eval_loss\"] = tf.metrics.mean(values=per_example_loss)\n return eval_dict\n\n\n eval_metrics = metric_fn(\n per_example_loss, label_ids, probabilities, is_real_example\n )\n output_spec = tf.estimator.EstimatorSpec(\n mode=mode,\n loss=total_loss,\n eval_metric_ops=eval_metrics,\n scaffold=scaffold_fn,\n )\n else:\n out = {\n \"input_ids\": input_ids,\n \"label_ids\": label_ids,\n }\n all_layers = model.get_all_encoder_layers()\n for (i, layer_index) in enumerate(layer_indexes):\n out[\"layer_output_%d\" % i] = all_layers[layer_index]\n\n output_spec = tf.estimator.EstimatorSpec(\n mode=mode, predictions=out, scaffold=scaffold_fn\n )\n return output_spec","def train(self):\n\n agent_step = self._num_actions_taken\n\n if agent_step >= self._train_after:\n if (agent_step % self._train_interval) == 0:\n pre_states, actions, post_states, rewards, terminals = self._memory.minibatch(self._minibatch_size)\n\n self._trainer.train_minibatch(\n self._trainer.loss_function.argument_map(\n pre_states=pre_states,\n actions=Value.one_hot(actions.reshape(-1, 1).tolist(), self.nb_actions),\n post_states=post_states,\n rewards=rewards,\n terminals=terminals\n )\n )\n\n # Update the Target Network if needed\n if (agent_step % self._target_update_interval) == 0:\n self._target_net = self._action_value_net.clone(CloneMethod.freeze)\n filename = \"models\\model%d\" % agent_step\n self._trainer.save_checkpoint(filename)","def train(self) -> Any:\n pass","def train(self, training_data):\n pass","def model_fn_builder(bert_config, init_checkpoint, learning_rate,\n num_train_steps, num_warmup_steps, use_one_hot_embeddings,\n input_seq_length, target_seq_length, target_start_ids, target_end_ids, batch_size,mode_type=\"lstm\"):\n mode_type=mode_type.lower()\n def model_fn(features, labels, mode, params):\n tf.logging.info(\"*** Features ***\")\n for name in sorted(features.keys()):\n tf.logging.info(\" name = %s, shape = %s\" % (name, features[name].shape))\n sentiment_labels = features[\"sentiment_labels\"]\n input_mask = features[\"input_mask\"]\n input_token_ids = features[\"input_token_ids\"]\n target_token_ids = features[\"target_token_ids\"]\n target_mask = features[\"target_mask\"]\n segment_ids = features[\"segment_ids\"]\n tf.logging.info(input_token_ids.shape)\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\n if mode_type==\"lstm_attention\":\n #lstm-attention\n (loss, logts, sample_id,scores,output_token_ids,outputs_mask) = create_model_lstm_attention(bert_config, is_training, input_token_ids, sentiment_labels, input_mask,\n segment_ids,\n target_token_ids, target_mask, target_start_ids, target_end_ids\n , input_seq_length,target_seq_length, mode, batch_size, use_one_hot_embeddings)\n elif mode_type==\"seq2seq_lstm_attention\":\n (loss, logts, sample_id,scores,output_token_ids,outputs_mask) = create_model_seq2seq_lstm_attention(bert_config, is_training, input_token_ids, sentiment_labels, input_mask,\n segment_ids,\n target_token_ids, target_mask, target_start_ids, target_end_ids\n , input_seq_length,target_seq_length, mode, batch_size, use_one_hot_embeddings)\n\n\n elif mode_type==\"lstm\":\n #lstm-nonattention\n (loss, logts, sample_id,scores,output_token_ids,outputs_mask) = create_model(bert_config, is_training, input_token_ids, sentiment_labels, input_mask,\n segment_ids,\n target_token_ids, target_mask, target_start_ids, target_end_ids\n , target_seq_length, mode, batch_size, use_one_hot_embeddings)\n elif mode_type==\"seq2seq_lstm_attention_with_condition\":\n (loss, logts, sample_id,scores,output_token_ids,outputs_mask) = create_model_seq2seq_lstm_attention_with_condition(bert_config, is_training, input_token_ids, sentiment_labels, input_mask,\n segment_ids,\n target_token_ids, target_mask, target_start_ids, target_end_ids\n , input_seq_length,target_seq_length, mode, batch_size, use_one_hot_embeddings)\n\n else:\n raise TypeError(\"None type with {} in ['lstm','lstm_attention']\".format(mode_type))\n\n tvars = tf.trainable_variables()\n initialized_variable_names = {}\n if init_checkpoint:\n (assignment_map, initialized_variable_names\n ) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n tf.logging.info(\"**** Trainable Variables ****\")\n for var in tvars:\n init_string = \"\"\n if var.name in initialized_variable_names:\n init_string = \", *INIT_FROM_CKPT*\"\n tf.logging.info(\" name = %s, shape = %s%s\", var.name, var.shape,\n init_string)\n if mode == tf.estimator.ModeKeys.TRAIN:\n\n train_op = optimization.create_optimizer(\n loss, learning_rate, num_train_steps, num_warmup_steps\n )\n accuracy = tf.metrics.accuracy(output_token_ids, sample_id, weights=outputs_mask)\n tf.summary.scalar(\"accuracy_train\", accuracy[1])\n output_spec = tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)\n\n elif mode == tf.estimator.ModeKeys.EVAL:\n\n accuracy = tf.metrics.accuracy(output_token_ids,sample_id , weights=outputs_mask)\n eval_metrics = {\"accuracy\": accuracy}\n tf.summary.scalar(\"accuracy_eval\", accuracy[1])\n output_spec = tf.estimator.EstimatorSpec(mode=mode, loss=loss\n , eval_metric_ops=eval_metrics)\n\n else:\n predictions={\"sample_id\": sample_id,\"inputs\":input_token_ids}\n if scores is not None:\n predictions[\"scores\"]=scores\n\n output_spec = tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)\n\n return output_spec\n\n return model_fn","def train(self, X, y):\n self.model.fit(X, y)","def train_models(self):\n\n #keep track on the number of iterations (needed to scale lambda)\n nr_iteration = 0\n \n for epoch in range(self.epochs):\n start = time.time()\n print()\n print(epoch + 1)\n print()\n for step, batch in enumerate(self.training_data):\n X_batch = normalize_images(tf.cast(batch[0], 'float32'))\n Y_batch = batch[1]\n Z_batch = self.ae_model.encode(X_batch)\n \n self.train_step_disc(Z_batch, Y_batch)\n # Call only one tf.function when tracing.\n #ADD LAMBDA SCHEDULE ACCORDING TO OUR EXPERIMENTS AND EPOCH LENGTH\n self.scale_lambda(self.lambda_e, nr_iteration)\n self.train_step_ae(X_batch, Y_batch, Z_batch)\n\n nr_iteration += 1\n end = time.time()\n print(\"Epoch \" + str(epoch + 1) + \" takes \" + str(end - start))","def train(model: ContinualModel, dataset: ContinualDataset,\n args: Namespace) -> None:\n model.net.to(model.device)\n results, results_mask_classes = [], []\n \n model_stash = create_stash(model, args, dataset)\n \n if args.csv_log:\n csv_logger = CsvLogger(dataset.SETTING, dataset.NAME, model.NAME)\n if args.tensorboard:\n tb_logger = TensorboardLogger(args, dataset.SETTING, model_stash)\n model_stash['tensorboard_name'] = tb_logger.get_name()\n \n dataset_copy = get_dataset(args)\n for t in range(dataset.N_TASKS):\n model.net.train()\n _, _ = dataset_copy.get_data_loaders()\n if model.NAME != 'icarl' and model.NAME != 'pnn':\n random_results_class, random_results_task = evaluate(model, dataset_copy)\n \n print(file=sys.stderr)\n for t in range(dataset.N_TASKS):\n model.net.train()\n train_loader, test_loader = dataset.get_data_loaders()\n if hasattr(model, 'begin_task'):\n model.begin_task(dataset)\n if t:\n accs = evaluate(model, dataset, last=True)\n results[t - 1] = results[t - 1] + accs[0]\n if dataset.SETTING == 'class-il':\n results_mask_classes[t - 1] = results_mask_classes[t - 1] + accs[1]\n for epoch in range(args.n_epochs):\n for i, data in enumerate(train_loader):\n if hasattr(dataset.train_loader.dataset, 'logits'):\n inputs, labels, not_aug_inputs, logits = data\n inputs = inputs.to(model.device)\n labels = labels.to(model.device)\n not_aug_inputs = not_aug_inputs.to(model.device)\n logits = logits.to(model.device)\n loss = model.observe(inputs, labels, not_aug_inputs, logits)\n else:\n inputs, labels, not_aug_inputs = data\n inputs, labels = inputs.to(model.device), labels.to(\n model.device)\n not_aug_inputs = not_aug_inputs.to(model.device)\n loss = model.observe(inputs, labels, not_aug_inputs)\n \n progress_bar(i, len(train_loader), epoch, t, loss)\n \n if args.tensorboard:\n tb_logger.log_loss(loss, args, epoch, t, i)\n \n model_stash['batch_idx'] = i + 1\n model_stash['epoch_idx'] = epoch + 1\n model_stash['batch_idx'] = 0\n model_stash['task_idx'] = t + 1\n model_stash['epoch_idx'] = 0\n \n if hasattr(model, 'end_task'):\n model.end_task(dataset)\n \n accs = evaluate(model, dataset)\n results.append(accs[0])\n results_mask_classes.append(accs[1])\n \n mean_acc = np.mean(accs, axis=1)\n print_mean_accuracy(mean_acc, t + 1, dataset.SETTING)\n \n model_stash['mean_accs'].append(mean_acc)\n if args.csv_log:\n csv_logger.log(mean_acc)\n if args.tensorboard:\n tb_logger.log_accuracy(np.array(accs), mean_acc, args, t)\n \n if args.csv_log:\n csv_logger.add_bwt(results, results_mask_classes)\n csv_logger.add_forgetting(results, results_mask_classes)\n if model.NAME != 'icarl' and model.NAME != 'pnn':\n csv_logger.add_fwt(results, random_results_class,\n results_mask_classes, random_results_task)\n \n if args.tensorboard:\n tb_logger.close()\n if args.csv_log:\n csv_logger.write(vars(args))","def model_fn_builder(albert_config,num_labels,init_checkpoint,learning_rate,\n num_train_steps,num_warmup_steps,\n use_one_hot_embeddings,optimizer='adamw'):\n\n def model_fn(features,labels,mode,params):\n \"\"\"The `model_fn` for TPUEstimator.\"\"\"\n tf.logging.info('*** Features ***')\n for name in sorted(features.keys()):\n tf.logging.info(\" name = %s ,shape = %s\" % (name,features[name].shape))\n\n input_ids = features['input_ids']\n input_mask = features['input_mask']\n segment_ids = features['segment_ids']\n label_ids = features['label_ids']\n if 'is_real_example' in features:\n is_real_example = tf.cast(features['is_real_example'],dtype=tf.float32)\n else:\n is_real_example = tf.ones(tf.shape(label_ids),dtype=tf.float32)\n\n is_training = (mode == tf_estimator.estimator.ModeKeys.TRAIN)\n\n (total_loss,per_example_loss,probabilities,predictions) = \\\n create_model(albert_config,is_training,input_ids,input_mask,\n segment_ids,label_ids,num_labels,\n use_one_hot_embeddings)\n\n tvars = tf.trainable_variables()\n initialized_variable_names = {}\n if init_checkpoint:\n (assignment_map,initialized_variable_names) = modeling.get_assignment_map_from_checkpoint(tvars,init_checkpoint)\n tf.train.init_from_checkpoint(init_checkpoint,assignment_map)\n\n tf.logging.info(\"**** Trainable Variables ****\")\n for var in tvars:\n init_string = \"\"\n if var.name in initialized_variable_names:\n init_string = \", *INIT_FROM_CKPT*\"\n tf.logging.info(\" name = %s, shape = %s%s\", var.name, var.shape,\n init_string)\n\n output_spec = None\n if mode == tf_estimator.estimator.ModeKeys.TRAIN:\n train_op = optimization.create_optimizer(total_loss,\n learning_rate,\n num_train_steps,\n num_warmup_steps,use_tpu=False)\n output_spec = tf_estimator.estimator.EstimatorSpec(\n mode=mode,\n loss=total_loss,\n train_op=train_op,\n )\n elif mode == tf_estimator.estimator.ModeKeys.EVAL:\n def metric_fn(per_example_loss,label_ids,logits,is_real_example):\n accuracy = tf.metrics.accuracy(\n labels=label_ids,predictions=predictions,\n weights=is_real_example\n )\n loss = tf.metrics.mean(\n values=per_example_loss,weights=is_real_example\n )\n return {\n 'eval_accuracy':accuracy,\n 'eval_loss':loss,\n }\n\n eval_metrics = metric_fn(per_example_loss,label_ids,predictions,is_real_example)\n output_spec = tf_estimator.estimator.EstimatorSpec(\n mode=mode,\n loss=total_loss,\n eval_metric_ops=eval_metrics\n )\n else:\n output_spec = tf_estimator.estimator.EstimatorSpec(\n mode=mode,\n predictions={\n 'probabilities':probabilities,\n 'predictions':predictions,\n },\n )\n\n return output_spec\n\n return model_fn","def _train_model(self, df_train):\n # type: (List[List[Tuple[Text, Text, Text, Text]]]) -> None\n import sklearn_crfsuite\n\n X_train = [self._sentence_to_features(sent) for sent in df_train]\n y_train = [self._sentence_to_labels(sent) for sent in df_train]\n\n from itertools import chain\n\n import nltk\n import sklearn\n import scipy.stats\n from sklearn.metrics import make_scorer\n from sklearn.model_selection import cross_val_score\n from sklearn.model_selection import RandomizedSearchCV\n\n import sklearn_crfsuite\n from sklearn_crfsuite import scorers\n from sklearn_crfsuite import metrics\n\n X_train = [self._sentence_to_features(sent) for sent in df_train]\n y_train = [self._sentence_to_labels(sent) for sent in df_train]\n\n if self.component_config[\"grid_search\"]:\n self.ent_tagger = sklearn_crfsuite.CRF(\n algorithm='lbfgs',\n # stop earlier\n max_iterations=self.component_config[\"max_iterations\"],\n # include transitions that are possible, but not observed\n all_possible_transitions=True\n )\n self.ent_tagger.fit(X_train, y_train)\n\n params_space = {\n 'c1': scipy.stats.expon(scale=0.5),\n 'c2': scipy.stats.expon(scale=0.5),\n }\n labels = self.ent_tagger.classes_\n\n # use the same metric for evaluation\n f1_scorer = make_scorer(metrics.flat_f1_score,\n average='weighted', labels=labels)\n\n # search\n rs = RandomizedSearchCV(self.ent_tagger, params_space,\n cv=10,\n verbose=1,\n n_jobs=-1,\n n_iter=100,\n scoring=f1_scorer)\n rs.fit(X_train, y_train)\n print('best params:', rs.best_params_)\n print('best CV score:', rs.best_score_)\n print('model size: {:0.2f}M'.format(rs.best_estimator_.size_ / 1000000))\n try:\n import json\n with open(\"tunning_score.json\", \"w\") as f:\n json.dump(rs.best_params_, f, sort_keys=True, indent=4)\n except Exception:\n pass\n self.ent_tagger = sklearn_crfsuite.CRF(\n algorithm='lbfgs',\n c1=rs.best_params_[\"c1\"],\n c2=rs.best_params_[\"c2\"],\n # stop earlier\n max_iterations=self.component_config[\"max_iterations\"],\n # include transitions that are possible, but not observed\n all_possible_transitions=True\n )\n else:\n print(\"L1_c\", self.component_config[\"L1_c\"])\n print(\"L2_c\", self.component_config[\"L2_c\"])\n self.ent_tagger = sklearn_crfsuite.CRF(\n algorithm='lbfgs',\n # coefficient for L1 penalty\n c1=self.component_config[\"L1_c\"],\n # coefficient for L2 penalty\n c2=self.component_config[\"L2_c\"],\n # stop earlier\n max_iterations=self.component_config[\"max_iterations\"],\n # include transitions that are possible, but not observed\n all_possible_transitions=True\n )\n\n self.ent_tagger.fit(X_train, y_train)","def train(train_x_df, train_y_df):\n x = list(train_x_df.columns.values)\n model = build_model(len(x))\n\n os.makedirs(\"./saved_models\", exist_ok=True)\n\n cp_callback = keras.callbacks.ModelCheckpoint(\n checkpoint_path, save_weights_only=True, save_best_only=True, verbose=1\n )\n\n # first 80 percent for training\n train_x = train_x_df[1:246005]\n train_y = train_y_df[1:246005]\n\n # other 20 percent for evaluating\n eval_x = train_x_df[246006 : len(train_x_df) - 1]\n eval_y = train_y_df[246006 : len(train_y_df) - 1]\n\n # train model\n model.fit(\n train_x,\n train_y,\n epochs=epochs,\n validation_split=0.2,\n verbose=0,\n batch_size=batch_size,\n callbacks=[cp_callback],\n )\n\n print(\"done training\")\n\n # export the tensorflow model to a onnx model file\n # for loading in tfe and secure enclave\n export_to_onnx(\n x,\n model,\n \"./house_credit_default.onnx\",\n )\n\n # evaluate the model using AUC, the metric used in the kaggle competition\n loss = model.evaluate(eval_x, eval_y, batch_size=batch_size)\n\n predictions = model.predict(eval_x, batch_size=batch_size)\n auc = tf.metrics.auc(eval_y, predictions)\n\n print(\"Evaluation Loss:\", loss[0])\n print(\"Accuracy:\", loss[1])\n print(\"AUC: \", auc[0][1])","def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:\n # Initialize feature extractor\n nltk.download('stopwords')\n stop_words = set(stopwords.words('english'))\n\n if args.model == \"TRIVIAL\":\n feat_extractor = None\n elif args.feats == \"UNIGRAM\":\n feat_extractor = UnigramFeatureExtractor(Indexer(), train_exs, stop_words)\n elif args.feats == \"BIGRAM\":\n # Add additional preprocessing code here\n feat_extractor = BigramFeatureExtractor(Indexer(), train_exs, stop_words)\n elif args.feats == \"BETTER\":\n # Add additional preprocessing code here\n feat_extractor = BetterFeatureExtractor(Indexer(), train_exs, stop_words)\n else:\n raise Exception(\"Pass in UNIGRAM, BIGRAM, or BETTER to run the appropriate system\")\n\n # Train the model\n if args.model == \"TRIVIAL\":\n model = TrivialSentimentClassifier()\n elif args.model == \"PERCEPTRON\":\n model = train_perceptron(train_exs, feat_extractor)\n elif args.model == \"LR\":\n model = train_logistic_regression(train_exs, feat_extractor)\n else:\n raise Exception(\"Pass in TRIVIAL, PERCEPTRON, or LR to run the appropriate system\")\n return model","def model_fn(features, labels, mode, params): # pylint: disable=unused-argument\n\n tf.logging.info(\"*** Features ***\")\n for name in sorted(features.keys()):\n tf.logging.info(\" name = %s, shape = %s\" % (name, features[name].shape))\n\n unique_ids = features[\"unique_ids\"]\n input_ids = features[\"input_ids\"]\n input_mask = features[\"input_mask\"]\n segment_ids = features[\"segment_ids\"]\n\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\n\n logits = create_model(\n bert_config=bert_config,\n is_training=is_training,\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n use_one_hot_embeddings=use_one_hot_embeddings)\n\n tvars = tf.trainable_variables()\n\n initialized_variable_names = {}\n\n if init_checkpoint:\n (assignment_map, initialized_variable_names\n ) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\n\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n tf.logging.info(\"**** Trainable Variables ****\")\n for var in tvars:\n init_string = \"\"\n if var.name in initialized_variable_names:\n init_string = \", *INIT_FROM_CKPT*\"\n tf.logging.info(\" name = %s, shape = %s%s\", var.name, var.shape,\n init_string)\n\n output_spec = None\n if mode == tf.estimator.ModeKeys.PREDICT:\n predictions = {\n \"unique_ids\": unique_ids,\n \"prediction\": tf.argmax(logits, axis=-1),\n }\n output_spec = tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)\n else:\n def compute_loss(logits, positions):\n one_hot_positions = tf.one_hot(\n positions, depth=3, dtype=tf.float32)\n log_probs = tf.nn.log_softmax(logits, axis=-1)\n loss = -tf.reduce_mean(\n tf.reduce_sum(one_hot_positions * log_probs, axis=-1))\n return loss\n\n label = features[\"label\"]\n\n loss = compute_loss(logits, label)\n predicted_classes = tf.argmax(logits, axis=-1)\n accuracy = tf.metrics.accuracy(labels=label, predictions=predicted_classes, name='acc_op')\n\n # global global_acc_list\n # global_acc_list.append(accuracy)\n if mode == tf.estimator.ModeKeys.TRAIN:\n train_op = optimization.create_optimizer(\n loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu)\n\n metrics = {'accuracy': accuracy}\n output_spec = tf.estimator.EstimatorSpec(\n mode=mode,\n loss=loss,\n eval_metric_ops=metrics,\n train_op=train_op)\n elif mode == tf.estimator.ModeKeys.EVAL:\n metrics = {'accuracy': accuracy}\n output_spec = tf.estimator.EstimatorSpec(mode, loss=loss, eval_metric_ops=metrics)\n else:\n raise ValueError(\n \"Only TRAIN and PREDICT modes are supported: %s\" % (mode))\n\n return output_spec","def _train(self, samples):\n for i, sample in enumerate(samples):\n # add extra info to samples\n sample = {\n 'src_tokens': sample[0],\n 'input_tokens': self._right_shifted_ys(sample[1]),\n 'target': sample[1],\n 'id': None\n }\n sample['ntokens'] = sum(len(t) for t in sample['target'])\n sample['src_positions'] = self._positions_for_tokens(\n sample['src_tokens'])\n sample['input_positions'] = self._positions_for_tokens(\n sample['input_tokens'])\n samples[i] = sample\n return self.trainer.train_step(samples)"],"string":"[\n \"def trainModel( self, featureTrain, classTrain):\",\n \"def run(self) -> None:\\n self.model = self.trainer.train_model(self.model, self.data)\",\n \"def training(self) -> None:\\n self.compile_model()\\n self.train_epoch()\\n self.agent.save()\",\n \"def train(self):\\n self.emission_model(self.train_data)\\n self.transition_model(self.train_data)\",\n \"def train(self):\\n\\t\\tself.model.fit(self.training_data, self.training_labels)\",\n \"def train(self, training_data, model_name):\\n dataset = []\\n for example in training_data:\\n entity_offsets = self._convert_example(example)\\n dataset.append(self._from_json_to_crf(example, entity_offsets))\\n\\n features = [self._sentence_to_features(s) for s in dataset]\\n labels = [self._sentence_to_labels(s) for s in dataset]\\n trainer = sklearn_crfsuite.CRF(\\n algorithm=\\\"lbfgs\\\",\\n # coefficient for L1 penalty\\n c1=0.1,\\n # coefficient for L2 penalty\\n c2=0.1,\\n # stop earlier\\n max_iterations=50,\\n # include transitions that are possible, but not observed\\n all_possible_transitions=True,\\n )\\n trainer.fit(features, labels)\\n logger.info(\\\"Creating Model for Intent %s\\\",model_name)\\n joblib.dump(trainer, 'core/agent/model_files/%s.model' % model_name)\\n return True\",\n \"def train_lm():\\n\\n print(\\\"\\\\n\\\\nTraining started at {} - {}\\\\n\\\\n\\\".format(\\n time.strftime(\\\"%d/%m/%Y\\\"), time.strftime(\\\"%H:%M:%S\\\")\\n ))\\n\\n config = get_config(FLAGS.config)\\n\\n vocabulary = read_vocabulary(config.data_files, config.vocab_size)\\n train_data, valid_data, test_data = read_lm_data(config.data_files,\\n vocabulary)\\n\\n with tf.Graph().as_default() as graph:\\n\\n # define a default initializer for the model\\n initializer = tf.random_uniform_initializer(\\n -config.init_scale, config.init_scale, seed=seed, dtype=tf.float32)\\n\\n # model for training\\n print(\\\"\\\\nBuilding Model for training...\\\")\\n with tf.name_scope(\\\"Train\\\"):\\n with tf.variable_scope(\\\"Model\\\", reuse=None, initializer=initializer):\\n\\n train_data_producer = lm_data_producer(train_data,\\n config.batch_size,\\n config.num_steps)\\n\\n train_queue = tf.FIFOQueue(\\n capacity=len(train_data_producer[0]), dtypes=[tf.int32, tf.int32],\\n shapes=[[config.num_steps]] * 2)\\n\\n train_inputs = tf.convert_to_tensor(train_data_producer[0],\\n dtype=tf.int32)\\n train_targets = tf.convert_to_tensor(train_data_producer[1],\\n dtype=tf.int32)\\n enqueue_op_train = train_queue.enqueue_many([train_inputs,\\n train_targets])\\n\\n qr_train = tf.train.QueueRunner(train_queue, [enqueue_op_train] * 2)\\n tf.train.add_queue_runner(qr_train)\\n\\n mtrain = AttentiveLM(is_training=True,\\n params=config,\\n batch_size=config.batch_size,\\n num_steps=config.num_steps,\\n queue=train_queue,\\n keep_attention_weights=False,\\n log_tensorboard=FLAGS.log_tensorboard)\\n print(\\\"Batch size: {:d}\\\".format(mtrain.batch_size))\\n print(\\\"# of steps: {:d}\\\".format(mtrain.num_steps))\\n\\n # model for validation\\n print(\\\"\\\\nBuilding Model for validation...\\\")\\n with tf.name_scope(\\\"Valid\\\"):\\n with tf.variable_scope(\\\"Model\\\", reuse=True, initializer=initializer):\\n\\n num_valid_steps = max([len(sample) for sample in valid_data])\\n valid_data_producer = lm_data_producer(\\n valid_data, config.batch_size, num_valid_steps)\\n\\n valid_queue = tf.FIFOQueue(\\n capacity=len(valid_data_producer[0]), dtypes=[tf.int32, tf.int32],\\n shapes=[[num_valid_steps]] * 2)\\n\\n valid_inputs = tf.convert_to_tensor(\\n valid_data_producer[0], dtype=tf.int32)\\n valid_targets = tf.convert_to_tensor(\\n valid_data_producer[1], dtype=tf.int32)\\n enqueue_op_valid = valid_queue.enqueue_many(\\n [valid_inputs, valid_targets])\\n\\n qr_valid = tf.train.QueueRunner(valid_queue, [enqueue_op_valid] * 2)\\n tf.train.add_queue_runner(qr_valid)\\n\\n mvalid = AttentiveLM(\\n is_training=False, params=config, batch_size=config.batch_size,\\n num_steps=num_valid_steps, queue=valid_queue,\\n keep_attention_weights=False)\\n print(\\\"# of validation steps: {:d}\\\".format(num_valid_steps))\\n\\n # configure the session\\n proto_config = tf.ConfigProto(allow_soft_placement=True,\\n log_device_placement=False)\\n\\n # save training and best models\\n saver = tf.train.Saver(max_to_keep=3)\\n saver_best = tf.train.Saver(max_to_keep=1)\\n\\n supervisor = tf.train.Supervisor(logdir=FLAGS.train_dir,\\n saver=saver, save_model_secs=0)\\n\\n with supervisor.managed_session(config=proto_config) as session:\\n\\n # supervisor.\\n\\n best_valid_ppx = np.inf\\n estop_counter = 0\\n\\n for epoch in range(FLAGS.max_epochs):\\n\\n lr_decay = config.lr_decay ** max(epoch - config.start_decay, 0.0)\\n mtrain.assign_lr(session, config.learning_rate * lr_decay)\\n\\n # print info\\n print(\\\"\\\\nEpoch: {:d} - Learning rate: {:e}\\\".format(\\n epoch, session.run(mtrain.lr_rate)))\\n\\n _ = run_epoch(session, mtrain, train_data, is_train=True)\\n\\n # Save checkpoint\\n print(\\\"\\\\nSaving current model...\\\")\\n checkpoint_path = os.path.join(FLAGS.train_dir, FLAGS.model_name)\\n saver.save(session, checkpoint_path, global_step=mtrain.global_step)\\n\\n print(\\\"\\\\nRunning validation...\\\")\\n valid_ppx = run_epoch(session, mvalid, valid_data, is_train=False)\\n print(\\\"Epoch {:d}: - Valid Perplexity: {:.8f}\\\".format(epoch, valid_ppx))\\n\\n # check early stop\\n if FLAGS.early_stop_patience > 0:\\n\\n if best_valid_ppx > valid_ppx:\\n best_valid_ppx = valid_ppx\\n estop_counter = 0\\n print('\\\\nSaving the best model so far...')\\n model_name = FLAGS.model_name + '-best'\\n best_model_path = os.path.join(FLAGS.best_models_dir, model_name)\\n saver_best.save(session, best_model_path,\\n global_step=mtrain.global_step)\\n else:\\n estop_counter += 1\\n\\n print(\\\"\\\\n\\\\tbest valid. ppx: {:.8f}\\\".format(best_valid_ppx))\\n print(\\\"early stop patience: {:d} - max {:d}\\\\n\\\".format(\\n estop_counter, FLAGS.early_stop_patience))\\n\\n if estop_counter >= FLAGS.early_stop_patience:\\n print('\\\\nEARLY STOP!\\\\n')\\n supervisor.request_stop()\\n supervisor.coord.join(threads)\\n break\\n\\n # when we ran the right number of epochs or we reached early stop we\\n # finish training\\n print(\\\"\\\\n\\\\nTraining finished at {} - {}\\\\n\\\\n\\\".format(\\n time.strftime(\\\"%d/%m/%Y\\\"), time.strftime(\\\"%H:%M:%S\\\")\\n ))\\n\\n with tf.Graph().as_default() as test_graph:\\n\\n # model for testing\\n print(\\\"\\\\n\\\\nBuilding Model for testing...\\\\n\\\")\\n with tf.name_scope(\\\"Test\\\"):\\n with tf.variable_scope(\\\"Model\\\", reuse=None, initializer=initializer):\\n num_test_steps = max([len(sample) for sample in test_data])\\n\\n test_data_producer = lm_data_producer(\\n test_data, config.batch_size, num_test_steps)\\n\\n test_queue = tf.FIFOQueue(\\n capacity=len(test_data_producer[0]), dtypes=[tf.int32, tf.int32],\\n shapes=[[num_test_steps]] * 2)\\n\\n test_inputs = tf.convert_to_tensor(\\n test_data_producer[0], dtype=tf.int32)\\n test_targets = tf.convert_to_tensor(\\n test_data_producer[1], dtype=tf.int32)\\n enqueue_op_test = test_queue.enqueue_many(\\n [test_inputs, test_targets])\\n\\n qr_test = tf.train.QueueRunner(test_queue, [enqueue_op_test] * 2)\\n tf.train.add_queue_runner(qr_test)\\n mtest = AttentiveLM(is_training=False,\\n params=config,\\n batch_size=config.batch_size,\\n num_steps=num_test_steps,\\n keep_attention_weights=True)\\n print(\\\"# of test steps: {:d}\\\".format(num_test_steps))\\n\\n saver_test = tf.train.Saver(max_to_keep=1)\\n test_supervisor = tf.train.Supervisor(\\n logdir=FLAGS.best_models_dir, summary_writer=None,\\n saver=saver_test, save_model_secs=0)\\n\\n with test_supervisor.managed_session(config=proto_config) as test_session:\\n # eval on test\\n print(\\\"\\\\nRunning test...\\\")\\n test_ppx = run_epoch(\\n test_session, mtest, test_data,\\n is_train=False, plot_attention_weights=True)\\n print(\\\"Test Perplexity: {:.8f}\\\".format(test_ppx))\\n\\n test_supervisor.request_stop()\\n test_supervisor.coord.join()\\n\\n sys.stdout.flush()\",\n \"def train(self):\\n p = self._params\\n if self.train_data != None:\\n tens_to_log = self.params.tens_to_log\\n logging_hook = tf.train.LoggingTensorHook(tensors = tens_to_log,\\n every_n_iter = p.logging_step,\\n )\\n t_fn = tf.estimator.inputs.numpy_input_fn(x = {\\\"x\\\": self.train_data[\\\"x\\\"]},\\n y = self.train_data[\\\"y\\\"],\\n batch_size = p.batch_size,\\n num_epochs = None,\\n shuffle = True,\\n )\\n self._model.train(input_fn = t_fn,\\n steps = self.params.training_steps,\\n hooks = [logging_hook],\\n )\\n \\n if self.eval_data != None:\\n e_fn = tf.estimator.inputs.numpy_input_fn(x = {\\\"x\\\": self.eval_data[\\\"x\\\"]},\\n y = self.eval_data[\\\"y\\\"],\\n num_epochs = 1,\\n shuffle = False,\\n )\\n eval_results = self.model.evaluate(input_fn = e_fn,\\n checkpoint_path = self.model_dir,\\n )\\n print(eval_results)\",\n \"def train(self):\\n # self.recognizer.train()\\n self.detector.train()\\n self.shared_conv.train()\",\n \"def train(self, training_data, cfg=None, **kwargs):\\r\\n # type: (TrainingData, Optional[RasaNLUModelConfig], **Any) -> None\\r\\n\\r\\n intent_dict = self._create_intent_dict(training_data)\\r\\n\\r\\n if len(intent_dict) < 2:\\r\\n logger.error(\\\"Can not train an intent classifier. \\\"\\r\\n \\\"Need at least 2 different classes. \\\"\\r\\n \\\"Skipping training of intent classifier.\\\")\\r\\n return\\r\\n\\r\\n self.inv_intent_dict = {v: k for k, v in intent_dict.items()}\\r\\n self.encoded_all_intents = self._create_encoded_intents(intent_dict)\\r\\n\\r\\n X, Y, intents_for_X = self._prepare_data_for_training(training_data, intent_dict)\\r\\n\\r\\n num_classes = len(intent_dict)\\r\\n\\r\\n intents_for_X = intents_for_X.astype(np.int32)\\r\\n\\r\\n data_size = len(X)\\r\\n indices = np.arange(data_size)\\r\\n train_size = int(data_size*2/3)\\r\\n\\r\\n\\r\\n train_x = X[indices[0:train_size]]\\r\\n train_y = intents_for_X[indices[0:train_size]]\\r\\n\\r\\n\\r\\n test_x = X[indices[train_size:data_size]]\\r\\n test_y = intents_for_X[indices[train_size:data_size]]\\r\\n\\r\\n\\r\\n\\r\\n # define classes number to classified\\r\\n head = tf.contrib.estimator.multi_class_head(n_classes=num_classes)\\r\\n\\r\\n # define feature spec for input x parsing\\r\\n feature_names = ['a_in']\\r\\n self.feature_columns = [tf.feature_column.numeric_column(key=k,shape=[1, train_x.shape[1]]) for k in feature_names]\\r\\n\\r\\n x_tensor_train = {'a_in': train_x}\\r\\n x_tensor_test = {'a_in': test_x}\\r\\n\\r\\n\\r\\n # set gpu and tf graph confing\\r\\n tf.logging.set_verbosity(tf.logging.INFO)\\r\\n config_proto = self.get_config_proto(self.component_config)\\r\\n\\r\\n # sparse_softmax_cross_entropy , build linear classified model\\r\\n self.estimator = tf.contrib.estimator.LinearEstimator(\\r\\n head = head,\\r\\n feature_columns=self.feature_columns,\\r\\n optimizer='Ftrl',\\r\\n config=tf.estimator.RunConfig(session_config=config_proto)\\r\\n )\\r\\n # train model\\r\\n self.estimator.train(input_fn=lambda: self.input_fn(x_tensor_train,\\r\\n train_y,\\r\\n self.batch_size,\\r\\n shuffle_num=1000,\\r\\n mode = tf.estimator.ModeKeys.TRAIN),\\r\\n max_steps=800)\\r\\n # evaluate model\\r\\n results = self.estimator.evaluate(input_fn=lambda: self.input_fn(x_tensor_test,\\r\\n test_y,\\r\\n self.batch_size,\\r\\n shuffle_num=1000,\\r\\n mode = tf.estimator.ModeKeys.PREDICT))\\r\\n\\r\\n logger.info(results)\",\n \"def train(self, X, y):\\n tf.logging.set_verbosity(\\n tf.logging.INFO) # comment if you don't want to display the information during training/evaluation\\n\\n X_train, X_test, y_train, y_test = train_test_split(\\n X, y, test_size=self.params[\\\"TEST_SIZE\\\"], random_state=42, stratify=y)\\n\\n self.label_list = y.unique()\\n\\n train_features = self.sentences_to_features(X_train, y_train)\\n test_features = self.sentences_to_features(X_test, y_test)\\n if DEBUG:\\n print(\\\"Transformation to features completed\\\")\\n\\n num_train_steps = int(\\n len(train_features) / self.params[\\\"BATCH_SIZE\\\"] * self.params[\\\"NUM_TRAIN_EPOCHS\\\"])\\n num_warmup_steps = int(\\n num_train_steps * self.params[\\\"WARMUP_PROPORTION\\\"])\\n\\n run_config = self.run_config_builder()\\n model_fn = self.model_fn_builder(len(self.label_list), self.params[\\\"LEARNING_RATE\\\"], num_train_steps,\\n num_warmup_steps)\\n self.estimator = self.estimator_builder(model_fn, run_config)\\n\\n train_input_fn = bert.run_classifier.input_fn_builder(features=train_features,\\n seq_length=self.params[\\\"MAX_SEQ_LENGTH\\\"],\\n is_training=True, drop_remainder=False)\\n if DEBUG:\\n print(\\\"Beginning Training!\\\")\\n current_time = time.time()\\n self.estimator.train(input_fn=train_input_fn,\\n max_steps=num_train_steps)\\n if DEBUG:\\n print(\\\"Training took time :\\\", time.time() - current_time,\\n \\\"s, or \\\", (time.time() - current_time) / 60, \\\"min\\\")\\n\\n self.classifier_trained = True\\n\\n test_input_fn = run_classifier.input_fn_builder(features=test_features,\\n seq_length=self.params[\\\"MAX_SEQ_LENGTH\\\"],\\n is_training=False, drop_remainder=False)\\n\\n # apply model on test set and print all metrics\\n if DEBUG:\\n print(\\\"Evaluating\\\")\\n self.estimator.evaluate(input_fn=test_input_fn, steps=None)\",\n \"def train(self) -> None:\\n\\n # Check if in the saved model path there is already a trained model\\n if self.config.TRN_HYPERP[\\\"save_path\\\"]:\\n if tf.saved_model.contains_saved_model(self.config.TRN_HYPERP[\\\"save_path\\\"]):\\n print(\\\"INFO: An existing saved model will be used for inference\\\\n\\\")\\n else:\\n params = {**self.config.TRN_HYPERP, **self.config.DATASET_HYPERP}\\n trainer = Trainer(**params)\\n\\n print(f\\\"INFO: Starting training ... \\\\n\\\")\\n start_time = time.time()\\n trainer.train()\\n print(f\\\"\\\\nINFO: Training completed in {round((time.time() - start_time)/60, 2)} minutes.\\\\n\\\")\\n\\n # Instantiate the saved translator for inference\\n saved_path = self.config.TRN_HYPERP[\\\"save_path\\\"]\\n self.saved_translator = tf.saved_model.load(saved_path)\\n else:\\n print(\\\"INFO: Path to save model wasn't provided in config file. Can't train the model\\\\n\\\")\",\n \"def _train_model(self):\\n self.experiment = EpisodicExperiment(self.task, self.agent)\\n n_epochs = int(self.rl_params.n_training_episodes / self.rl_params.n_episodes_per_epoch)\\n logger.debug(\\\"Fitting user model over {} epochs, each {} episodes, total {} episodes.\\\"\\n .format(n_epochs, self.rl_params.n_episodes_per_epoch, n_epochs*self.rl_params.n_episodes_per_epoch))\\n for i in range(n_epochs):\\n logger.debug(\\\"RL epoch {}\\\".format(i))\\n self.experiment.doEpisodes(self.rl_params.n_episodes_per_epoch)\\n self.agent.learn()\\n self.agent.reset() # reset buffers\",\n \"def train():\\n pass\",\n \"def train_model(self, *args, **kwargs):\\n self.model.train(self.training, *args, **kwargs)\",\n \"def train_nlp(model: ContinualModel, dataset: ContinualDataset,\\n args: Namespace) -> None:\\n model.net.to(model.device)\\n results, results_mask_classes = [], []\\n \\n model_stash = create_stash(model, args, dataset)\\n \\n if args.csv_log:\\n csv_logger = CsvLogger(dataset.SETTING, dataset.NAME, model.NAME)\\n if args.tensorboard:\\n tb_logger = TensorboardLogger(args, dataset.SETTING, model_stash)\\n model_stash['tensorboard_name'] = tb_logger.get_name()\\n \\n dataset_copy = get_dataset(args)\\n \\n for t in range(dataset.N_TASKS):\\n model.net.train()\\n _, _ = dataset_copy.get_data_loaders()\\n if model.NAME != 'icarl' and model.NAME != 'pnn':\\n # for forward transfer calculation\\n random_results_class, random_results_task = evaluate_nlp(model, dataset_copy)\\n \\n print(file=sys.stderr)\\n # start time\\n start_time = time.time()\\n for t in range(dataset.N_TASKS):\\n model.net.train()\\n train_loader, test_loader = dataset.get_data_loaders()\\n if hasattr(model, 'begin_task'):\\n model.begin_task(dataset)\\n if t:\\n accs = evaluate_nlp(model, dataset, last=True)\\n results[t - 1] = results[t - 1] + accs[0]\\n if dataset.SETTING == 'class-il':\\n results_mask_classes[t - 1] = results_mask_classes[t - 1] + accs[1]\\n for epoch in range(args.n_epochs):\\n for i, data in enumerate(train_loader):\\n if hasattr(dataset.train_loader.dataset, 'logits'):\\n # todo: to add logits\\n pass\\n else:\\n xs, ys, x_token_idxs, x_token_masks, y_token_idxs, y_token_masks, y_idxs = data\\n \\n x_token_idxs = x_token_idxs.to(model.device)\\n x_token_masks = x_token_masks.to(model.device)\\n y_token_idxs = y_token_idxs.to(model.device)\\n y_token_masks = y_token_masks.to(model.device)\\n y_idxs = y_idxs.to(model.device)\\n task_id = torch.tensor(t, dtype=torch.int64, requires_grad=False)\\n task_id = task_id.to(model.device)\\n \\n if model.require_task_id:\\n loss = model.observe(inputs=x_token_idxs, inputs_mask=x_token_masks, labels=y_idxs,\\n labels_name=y_token_idxs, labels_mask=y_token_masks, task_labels=task_id)\\n else:\\n loss = model.observe(inputs=x_token_idxs, inputs_mask=x_token_masks, labels=y_idxs,\\n labels_name=y_token_idxs, labels_mask=y_token_masks)\\n \\n progress_bar(i, len(train_loader), epoch, t, loss)\\n \\n if args.tensorboard:\\n tb_logger.log_loss(loss, args, epoch, t, i)\\n \\n model_stash['batch_idx'] = i + 1\\n model_stash['epoch_idx'] = epoch + 1\\n model_stash['batch_idx'] = 0\\n \\n model_stash['task_idx'] = t + 1\\n model_stash['epoch_idx'] = 0\\n \\n if hasattr(model, 'end_task'):\\n model.end_task(dataset)\\n \\n # reduce the running freq\\n # if (t+1) % args.eval_freq == 0:\\n accs = evaluate_nlp(model, dataset)\\n results.append(accs[0])\\n results_mask_classes.append(accs[1])\\n \\n mean_acc = np.mean(accs, axis=1)\\n print_mean_accuracy(mean_acc, t + 1, dataset.SETTING)\\n \\n # prob_model\\n if args.prob_all_tasks:\\n if args.prob_type != \\\"\\\":\\n for prob_l in range(12):\\n prob_l += 1\\n if args.prob_type == \\\"proto\\\":\\n p_accs = prob_proto_nlp(model, dataset, prob_l=prob_l)\\n else:\\n p_accs = prob_final_nlp(model, dataset, prob_l=prob_l)\\n p_mean_acc = np.mean(p_accs, axis=1)\\n print(\\\"task {} prob_l {}: mean_acc {}, masked_mean_acc {}\\\".format(t + 1,\\n prob_l,\\n round(p_mean_acc[0], 2),\\n round(p_mean_acc[1], 2)))\\n if args.csv_log:\\n csv_logger.log_task_prob(p_mean_acc, t)\\n \\n model_stash['mean_accs'].append(mean_acc)\\n if args.csv_log:\\n csv_logger.log(mean_acc)\\n if args.tensorboard:\\n tb_logger.log_accuracy(np.array(accs), mean_acc, args, t)\\n \\n running_time = time.time() - start_time\\n \\n # prob_model\\n if args.prob_type != \\\"\\\" and not args.prob_all_tasks:\\n for prob_l in range(12):\\n prob_l += 1\\n if args.prob_type == \\\"proto\\\":\\n accs = prob_proto_nlp(model, dataset, prob_l=prob_l)\\n else:\\n accs = prob_final_nlp(model, dataset, prob_l=prob_l)\\n mean_acc = np.mean(accs, axis=1)\\n print(\\\"prob_l {}: mean_acc {}, masked_mean_acc {}\\\".format(prob_l, mean_acc[0], mean_acc[1]))\\n if args.csv_log:\\n csv_logger.log_prob(mean_acc)\\n \\n if args.csv_log:\\n csv_logger.add_bwt(results, results_mask_classes)\\n csv_logger.add_running_time(running_time)\\n csv_logger.add_forgetting(results, results_mask_classes)\\n if model.NAME != 'icarl' and model.NAME != 'pnn':\\n csv_logger.add_fwt(results, random_results_class,\\n results_mask_classes, random_results_task)\\n \\n if args.tensorboard:\\n tb_logger.close()\\n if args.csv_log:\\n csv_logger.write(vars(args))\",\n \"def train(self, x, t):\\n for i in range(self.number_model):\\n curr_model = self.all_model[i]\\n curr_model.fit(x, t)\",\n \"def train_model(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def train(self):\\n self.log(f\\\"{self.cur_file_path}\\\\t\\\\tInfo: train method invoked!\\\")\\n self.log(f\\\"{self.cur_file_path}\\\\t\\\\tInfo: training {self.model.__class__.__name__} model!\\\")\\n\\n self.model.fit(self.trainX, self.trainY)\",\n \"def train_model(self):\\r\\n alpha, accuracy_rate = self.select_model()\\r\\n # Initialize logistic regression with alpha(learning rate)\\r\\n lg = logisticregression(C=alpha)\\r\\n # Train the model.\\r\\n lg.fit(self.training_data, self.target_data)\\r\\n # Save the trained model as .pkl file.\\r\\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\\r\\n print \\\"Estimated Parameters of Logistic Regression\\\"\\r\\n # Estimated parameters of logistic regression.\\r\\n print lg.get_params()\",\n \"def train(self):\\n model = TreeTrainer.train(self)\\n model['latent'] = self._latent\\n model['suffstats'] = {\\n 'vert_ss': self._vert_ss,\\n 'edge_ss': self._edge_ss,\\n 'feat_ss': self._feat_ss,\\n }\\n return model\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train():\\n import training\\n\\n # Ensure output directories exist\\n os.makedirs(os.path.dirname(cfg.scaler_path), exist_ok=True)\\n os.makedirs(cfg.model_path, exist_ok=True)\\n os.makedirs(cfg.log_path, exist_ok=True)\\n\\n # Load (standardized) input data and target values\\n tr_x, tr_y, _ = _load_data(cfg.training_set, is_training=True)\\n val_x, val_y, _ = _load_data(cfg.validation_set)\\n\\n # Try to create reproducible results\\n np.random.seed(cfg.initial_seed)\\n\\n # Save free parameters to disk\\n utils.log_parameters(cfg.training, os.path.join(cfg.model_path,\\n 'parameters.json'))\\n\\n training.train(tr_x, tr_y, val_x, val_y)\",\n \"def train():\\n import trace\\n trace.train()\",\n \"def train(self, model, args):\\n if model == self.WORD_DET_RFC:\\n return self.train_rfc(args)\\n elif model == self.REGRESSION_PARAMS:\\n return self.train_bb_reg(args)\\n else:\\n raise Exception('No model %s exists to train' % model)\",\n \"def train(self, X_train, y_train):\\n self.model.fit(X_train, y_train)\",\n \"def train_agent(self):\\n # Retrieve collected experiences from memory\\n experiences = np.array(self.replay.get_all())\\n # rewards = np.array([h['reward'] for h in experiences])\\n #rewards = experiences[:,2]\\n rewards = np.array([r[2] for r in experiences])\\n\\n # Discount and normalize rewards\\n norm_rewards = self.discount_rewards_and_normalize(rewards)\\n\\n # Shuffle for better learning\\n shuffled_experiences = np.random.shuffle(experiences)\\n\\n # Feed the experiences through the network with rewards to compute and\\n # minimize the loss.\\n\\n feed={\\n self.X: [r[0] for r in experiences],\\n self.rewards:norm_rewards,\\n self.ep_actions:experiences[:,1]\\n }\\n self.tf_sess.run(self.train,feed_dict=feed)\\n\\n pass\",\n \"def train(\\n # fmt: off\\n lang: (\\\"Model language\\\", \\\"positional\\\", None, str),\\n output_path: (\\\"Output directory to store model in\\\", \\\"positional\\\", None, Path),\\n train_path: (\\\"Location of JSON-formatted training data\\\", \\\"positional\\\", None, Path),\\n dev_path: (\\\"Location of JSON-formatted development data\\\", \\\"positional\\\", None, Path),\\n raw_text: (\\\"Path to jsonl file with unlabelled text documents.\\\", \\\"option\\\", \\\"rt\\\", Path) = None,\\n base_model: (\\\"Name of model to update (optional)\\\", \\\"option\\\", \\\"b\\\", str) = None,\\n pipeline: (\\\"Comma-separated names of pipeline components\\\", \\\"option\\\", \\\"p\\\", str) = \\\"tagger,parser,ner\\\",\\n vectors: (\\\"Model to load vectors from\\\", \\\"option\\\", \\\"v\\\", str) = None,\\n replace_components: (\\\"Replace components from base model\\\", \\\"flag\\\", \\\"R\\\", bool) = False,\\n n_iter: (\\\"Number of iterations\\\", \\\"option\\\", \\\"n\\\", int) = 30,\\n n_early_stopping: (\\\"Maximum number of training epochs without dev accuracy improvement\\\", \\\"option\\\", \\\"ne\\\", int) = None,\\n n_examples: (\\\"Number of examples\\\", \\\"option\\\", \\\"ns\\\", int) = 0,\\n use_gpu: (\\\"Use GPU\\\", \\\"option\\\", \\\"g\\\", int) = -1,\\n version: (\\\"Model version\\\", \\\"option\\\", \\\"V\\\", str) = \\\"0.0.0\\\",\\n meta_path: (\\\"Optional path to meta.json to use as base.\\\", \\\"option\\\", \\\"m\\\", Path) = None,\\n init_tok2vec: (\\\"Path to pretrained weights for the token-to-vector parts of the models. See 'spacy pretrain'. Experimental.\\\", \\\"option\\\", \\\"t2v\\\", Path) = None,\\n parser_multitasks: (\\\"Side objectives for parser CNN, e.g. 'dep' or 'dep,tag'\\\", \\\"option\\\", \\\"pt\\\", str) = \\\"\\\",\\n entity_multitasks: (\\\"Side objectives for NER CNN, e.g. 'dep' or 'dep,tag'\\\", \\\"option\\\", \\\"et\\\", str) = \\\"\\\",\\n noise_level: (\\\"Amount of corruption for data augmentation\\\", \\\"option\\\", \\\"nl\\\", float) = 0.0,\\n orth_variant_level: (\\\"Amount of orthography variation for data augmentation\\\", \\\"option\\\", \\\"ovl\\\", float) = 0.0,\\n eval_beam_widths: (\\\"Beam widths to evaluate, e.g. 4,8\\\", \\\"option\\\", \\\"bw\\\", str) = \\\"\\\",\\n gold_preproc: (\\\"Use gold preprocessing\\\", \\\"flag\\\", \\\"G\\\", bool) = False,\\n learn_tokens: (\\\"Make parser learn gold-standard tokenization\\\", \\\"flag\\\", \\\"T\\\", bool) = False,\\n textcat_multilabel: (\\\"Textcat classes aren't mutually exclusive (multilabel)\\\", \\\"flag\\\", \\\"TML\\\", bool) = False,\\n textcat_arch: (\\\"Textcat model architecture\\\", \\\"option\\\", \\\"ta\\\", str) = \\\"bow\\\",\\n textcat_positive_label: (\\\"Textcat positive label for binary classes with two labels\\\", \\\"option\\\", \\\"tpl\\\", str) = None,\\n tag_map_path: (\\\"Location of JSON-formatted tag map\\\", \\\"option\\\", \\\"tm\\\", Path) = None,\\n verbose: (\\\"Display more information for debug\\\", \\\"flag\\\", \\\"VV\\\", bool) = False,\\n debug: (\\\"Run data diagnostics before training\\\", \\\"flag\\\", \\\"D\\\", bool) = False,\\n # fmt: on\\n):\\n util.fix_random_seed()\\n util.set_env_log(verbose)\\n\\n # Make sure all files and paths exists if they are needed\\n train_path = util.ensure_path(train_path)\\n dev_path = util.ensure_path(dev_path)\\n meta_path = util.ensure_path(meta_path)\\n output_path = util.ensure_path(output_path)\\n if raw_text is not None:\\n raw_text = list(srsly.read_jsonl(raw_text))\\n if not train_path or not train_path.exists():\\n msg.fail(\\\"Training data not found\\\", train_path, exits=1)\\n if not dev_path or not dev_path.exists():\\n msg.fail(\\\"Development data not found\\\", dev_path, exits=1)\\n if meta_path is not None and not meta_path.exists():\\n msg.fail(\\\"Can't find model meta.json\\\", meta_path, exits=1)\\n meta = srsly.read_json(meta_path) if meta_path else {}\\n if output_path.exists() and [p for p in output_path.iterdir() if p.is_dir()]:\\n msg.warn(\\n \\\"Output directory is not empty\\\",\\n \\\"This can lead to unintended side effects when saving the model. \\\"\\n \\\"Please use an empty directory or a different path instead. If \\\"\\n \\\"the specified output path doesn't exist, the directory will be \\\"\\n \\\"created for you.\\\",\\n )\\n if not output_path.exists():\\n output_path.mkdir()\\n msg.good(f\\\"Created output directory: {output_path}\\\")\\n\\n tag_map = {}\\n if tag_map_path is not None:\\n tag_map = srsly.read_json(tag_map_path)\\n # Take dropout and batch size as generators of values -- dropout\\n # starts high and decays sharply, to force the optimizer to explore.\\n # Batch size starts at 1 and grows, so that we make updates quickly\\n # at the beginning of training.\\n dropout_rates = util.decaying(\\n util.env_opt(\\\"dropout_from\\\", 0.2),\\n util.env_opt(\\\"dropout_to\\\", 0.2),\\n util.env_opt(\\\"dropout_decay\\\", 0.0),\\n )\\n batch_sizes = util.compounding(\\n util.env_opt(\\\"batch_from\\\", 100.0),\\n util.env_opt(\\\"batch_to\\\", 1000.0),\\n util.env_opt(\\\"batch_compound\\\", 1.001),\\n )\\n\\n if not eval_beam_widths:\\n eval_beam_widths = [1]\\n else:\\n eval_beam_widths = [int(bw) for bw in eval_beam_widths.split(\\\",\\\")]\\n if 1 not in eval_beam_widths:\\n eval_beam_widths.append(1)\\n eval_beam_widths.sort()\\n has_beam_widths = eval_beam_widths != [1]\\n\\n default_dir = Path(__file__).parent.parent / \\\"ml\\\" / \\\"models\\\" / \\\"defaults\\\"\\n\\n # Set up the base model and pipeline. If a base model is specified, load\\n # the model and make sure the pipeline matches the pipeline setting. If\\n # training starts from a blank model, intitalize the language class.\\n pipeline = [p.strip() for p in pipeline.split(\\\",\\\")]\\n msg.text(f\\\"Training pipeline: {pipeline}\\\")\\n disabled_pipes = None\\n pipes_added = False\\n if use_gpu >= 0:\\n activated_gpu = None\\n try:\\n activated_gpu = set_gpu(use_gpu)\\n except Exception as e:\\n msg.warn(f\\\"Exception: {e}\\\")\\n if activated_gpu is not None:\\n msg.text(f\\\"Using GPU: {use_gpu}\\\")\\n else:\\n msg.warn(f\\\"Unable to activate GPU: {use_gpu}\\\")\\n msg.text(\\\"Using CPU only\\\")\\n use_gpu = -1\\n if base_model:\\n msg.text(f\\\"Starting with base model '{base_model}'\\\")\\n nlp = util.load_model(base_model)\\n if nlp.lang != lang:\\n msg.fail(\\n f\\\"Model language ('{nlp.lang}') doesn't match language \\\"\\n f\\\"specified as `lang` argument ('{lang}') \\\",\\n exits=1,\\n )\\n if vectors:\\n msg.text(f\\\"Loading vectors from model '{vectors}'\\\")\\n _load_vectors(nlp, vectors)\\n\\n nlp.select_pipes(disable=[p for p in nlp.pipe_names if p not in pipeline])\\n for pipe in pipeline:\\n # first, create the model.\\n # Bit of a hack after the refactor to get the vectors into a default config\\n # use train-from-config instead :-)\\n if pipe == \\\"parser\\\":\\n config_loc = default_dir / \\\"parser_defaults.cfg\\\"\\n elif pipe == \\\"tagger\\\":\\n config_loc = default_dir / \\\"tagger_defaults.cfg\\\"\\n elif pipe == \\\"ner\\\":\\n config_loc = default_dir / \\\"ner_defaults.cfg\\\"\\n elif pipe == \\\"textcat\\\":\\n config_loc = default_dir / \\\"textcat_defaults.cfg\\\"\\n elif pipe == \\\"senter\\\":\\n config_loc = default_dir / \\\"senter_defaults.cfg\\\"\\n else:\\n raise ValueError(f\\\"Component {pipe} currently not supported.\\\")\\n pipe_cfg = util.load_config(config_loc, create_objects=False)\\n if vectors:\\n pretrained_config = {\\n \\\"@architectures\\\": \\\"spacy.VocabVectors.v1\\\",\\n \\\"name\\\": vectors,\\n }\\n pipe_cfg[\\\"model\\\"][\\\"tok2vec\\\"][\\\"pretrained_vectors\\\"] = pretrained_config\\n\\n if pipe == \\\"parser\\\":\\n pipe_cfg[\\\"learn_tokens\\\"] = learn_tokens\\n elif pipe == \\\"textcat\\\":\\n pipe_cfg[\\\"exclusive_classes\\\"] = not textcat_multilabel\\n pipe_cfg[\\\"architecture\\\"] = textcat_arch\\n pipe_cfg[\\\"positive_label\\\"] = textcat_positive_label\\n\\n if pipe not in nlp.pipe_names:\\n msg.text(f\\\"Adding component to base model '{pipe}'\\\")\\n nlp.add_pipe(nlp.create_pipe(pipe, config=pipe_cfg))\\n pipes_added = True\\n elif replace_components:\\n msg.text(f\\\"Replacing component from base model '{pipe}'\\\")\\n nlp.replace_pipe(pipe, nlp.create_pipe(pipe, config=pipe_cfg))\\n pipes_added = True\\n else:\\n if pipe == \\\"textcat\\\":\\n textcat_cfg = nlp.get_pipe(\\\"textcat\\\").cfg\\n base_cfg = {\\n \\\"exclusive_classes\\\": textcat_cfg[\\\"exclusive_classes\\\"],\\n \\\"architecture\\\": textcat_cfg[\\\"architecture\\\"],\\n \\\"positive_label\\\": textcat_cfg[\\\"positive_label\\\"],\\n }\\n if base_cfg != pipe_cfg:\\n msg.fail(\\n f\\\"The base textcat model configuration does\\\"\\n f\\\"not match the provided training options. \\\"\\n f\\\"Existing cfg: {base_cfg}, provided cfg: {pipe_cfg}\\\",\\n exits=1,\\n )\\n msg.text(f\\\"Extending component from base model '{pipe}'\\\")\\n disabled_pipes = nlp.select_pipes(\\n disable=[p for p in nlp.pipe_names if p not in pipeline]\\n )\\n else:\\n msg.text(f\\\"Starting with blank model '{lang}'\\\")\\n lang_cls = util.get_lang_class(lang)\\n nlp = lang_cls()\\n\\n if vectors:\\n msg.text(f\\\"Loading vectors from model '{vectors}'\\\")\\n _load_vectors(nlp, vectors)\\n\\n for pipe in pipeline:\\n # first, create the model.\\n # Bit of a hack after the refactor to get the vectors into a default config\\n # use train-from-config instead :-)\\n if pipe == \\\"parser\\\":\\n config_loc = default_dir / \\\"parser_defaults.cfg\\\"\\n elif pipe == \\\"tagger\\\":\\n config_loc = default_dir / \\\"tagger_defaults.cfg\\\"\\n elif pipe == \\\"morphologizer\\\":\\n config_loc = default_dir / \\\"morphologizer_defaults.cfg\\\"\\n elif pipe == \\\"ner\\\":\\n config_loc = default_dir / \\\"ner_defaults.cfg\\\"\\n elif pipe == \\\"textcat\\\":\\n config_loc = default_dir / \\\"textcat_defaults.cfg\\\"\\n elif pipe == \\\"senter\\\":\\n config_loc = default_dir / \\\"senter_defaults.cfg\\\"\\n else:\\n raise ValueError(f\\\"Component {pipe} currently not supported.\\\")\\n pipe_cfg = util.load_config(config_loc, create_objects=False)\\n if vectors:\\n pretrained_config = {\\n \\\"@architectures\\\": \\\"spacy.VocabVectors.v1\\\",\\n \\\"name\\\": vectors,\\n }\\n pipe_cfg[\\\"model\\\"][\\\"tok2vec\\\"][\\\"pretrained_vectors\\\"] = pretrained_config\\n\\n if pipe == \\\"parser\\\":\\n pipe_cfg[\\\"learn_tokens\\\"] = learn_tokens\\n elif pipe == \\\"textcat\\\":\\n pipe_cfg[\\\"exclusive_classes\\\"] = not textcat_multilabel\\n pipe_cfg[\\\"architecture\\\"] = textcat_arch\\n pipe_cfg[\\\"positive_label\\\"] = textcat_positive_label\\n\\n pipe = nlp.create_pipe(pipe, config=pipe_cfg)\\n nlp.add_pipe(pipe)\\n\\n # Update tag map with provided mapping\\n nlp.vocab.morphology.tag_map.update(tag_map)\\n\\n # Multitask objectives\\n multitask_options = [(\\\"parser\\\", parser_multitasks), (\\\"ner\\\", entity_multitasks)]\\n for pipe_name, multitasks in multitask_options:\\n if multitasks:\\n if pipe_name not in pipeline:\\n msg.fail(\\n f\\\"Can't use multitask objective without '{pipe_name}' in \\\"\\n f\\\"the pipeline\\\"\\n )\\n pipe = nlp.get_pipe(pipe_name)\\n for objective in multitasks.split(\\\",\\\"):\\n pipe.add_multitask_objective(objective)\\n\\n # Prepare training corpus\\n msg.text(f\\\"Counting training words (limit={n_examples})\\\")\\n corpus = GoldCorpus(train_path, dev_path, limit=n_examples)\\n n_train_words = corpus.count_train()\\n\\n if base_model and not pipes_added:\\n # Start with an existing model, use default optimizer\\n optimizer = create_default_optimizer()\\n else:\\n # Start with a blank model, call begin_training\\n cfg = {\\\"device\\\": use_gpu}\\n optimizer = nlp.begin_training(lambda: corpus.train_examples, **cfg)\\n nlp._optimizer = None\\n\\n # Load in pretrained weights (TODO: this may be broken in the config rewrite)\\n if init_tok2vec is not None:\\n components = _load_pretrained_tok2vec(nlp, init_tok2vec)\\n msg.text(f\\\"Loaded pretrained tok2vec for: {components}\\\")\\n\\n # Verify textcat config\\n if \\\"textcat\\\" in pipeline:\\n textcat_labels = nlp.get_pipe(\\\"textcat\\\").cfg.get(\\\"labels\\\", [])\\n if textcat_positive_label and textcat_positive_label not in textcat_labels:\\n msg.fail(\\n f\\\"The textcat_positive_label (tpl) '{textcat_positive_label}' \\\"\\n f\\\"does not match any label in the training data.\\\",\\n exits=1,\\n )\\n if textcat_positive_label and len(textcat_labels) != 2:\\n msg.fail(\\n \\\"A textcat_positive_label (tpl) '{textcat_positive_label}' was \\\"\\n \\\"provided for training data that does not appear to be a \\\"\\n \\\"binary classification problem with two labels.\\\",\\n exits=1,\\n )\\n train_data = corpus.train_data(\\n nlp,\\n noise_level=noise_level,\\n gold_preproc=gold_preproc,\\n max_length=0,\\n ignore_misaligned=True,\\n )\\n train_labels = set()\\n if textcat_multilabel:\\n multilabel_found = False\\n for ex in train_data:\\n train_labels.update(ex.gold.cats.keys())\\n if list(ex.gold.cats.values()).count(1.0) != 1:\\n multilabel_found = True\\n if not multilabel_found and not base_model:\\n msg.warn(\\n \\\"The textcat training instances look like they have \\\"\\n \\\"mutually-exclusive classes. Remove the flag \\\"\\n \\\"'--textcat-multilabel' to train a classifier with \\\"\\n \\\"mutually-exclusive classes.\\\"\\n )\\n if not textcat_multilabel:\\n for ex in train_data:\\n train_labels.update(ex.gold.cats.keys())\\n if list(ex.gold.cats.values()).count(1.0) != 1 and not base_model:\\n msg.warn(\\n \\\"Some textcat training instances do not have exactly \\\"\\n \\\"one positive label. Modifying training options to \\\"\\n \\\"include the flag '--textcat-multilabel' for classes \\\"\\n \\\"that are not mutually exclusive.\\\"\\n )\\n nlp.get_pipe(\\\"textcat\\\").cfg[\\\"exclusive_classes\\\"] = False\\n textcat_multilabel = True\\n break\\n if base_model and set(textcat_labels) != train_labels:\\n msg.fail(\\n f\\\"Cannot extend textcat model using data with different \\\"\\n f\\\"labels. Base model labels: {textcat_labels}, training data \\\"\\n f\\\"labels: {list(train_labels)}\\\",\\n exits=1,\\n )\\n if textcat_multilabel:\\n msg.text(\\n f\\\"Textcat evaluation score: ROC AUC score macro-averaged across \\\"\\n f\\\"the labels '{', '.join(textcat_labels)}'\\\"\\n )\\n elif textcat_positive_label and len(textcat_labels) == 2:\\n msg.text(\\n f\\\"Textcat evaluation score: F1-score for the \\\"\\n f\\\"label '{textcat_positive_label}'\\\"\\n )\\n elif len(textcat_labels) > 1:\\n if len(textcat_labels) == 2:\\n msg.warn(\\n \\\"If the textcat component is a binary classifier with \\\"\\n \\\"exclusive classes, provide '--textcat_positive_label' for \\\"\\n \\\"an evaluation on the positive class.\\\"\\n )\\n msg.text(\\n f\\\"Textcat evaluation score: F1-score macro-averaged across \\\"\\n f\\\"the labels '{', '.join(textcat_labels)}'\\\"\\n )\\n else:\\n msg.fail(\\n \\\"Unsupported textcat configuration. Use `spacy debug-data` \\\"\\n \\\"for more information.\\\"\\n )\\n\\n # fmt: off\\n row_head, output_stats = _configure_training_output(pipeline, use_gpu, has_beam_widths)\\n row_widths = [len(w) for w in row_head]\\n row_settings = {\\\"widths\\\": row_widths, \\\"aligns\\\": tuple([\\\"r\\\" for i in row_head]), \\\"spacing\\\": 2}\\n # fmt: on\\n print(\\\"\\\")\\n msg.row(row_head, **row_settings)\\n msg.row([\\\"-\\\" * width for width in row_settings[\\\"widths\\\"]], **row_settings)\\n try:\\n iter_since_best = 0\\n best_score = 0.0\\n for i in range(n_iter):\\n train_data = corpus.train_dataset(\\n nlp,\\n noise_level=noise_level,\\n orth_variant_level=orth_variant_level,\\n gold_preproc=gold_preproc,\\n max_length=0,\\n ignore_misaligned=True,\\n )\\n if raw_text:\\n random.shuffle(raw_text)\\n raw_batches = util.minibatch(\\n (nlp.make_doc(rt[\\\"text\\\"]) for rt in raw_text), size=8\\n )\\n words_seen = 0\\n with tqdm.tqdm(total=n_train_words, leave=False) as pbar:\\n losses = {}\\n for batch in util.minibatch_by_words(train_data, size=batch_sizes):\\n if not batch:\\n continue\\n try:\\n nlp.update(\\n batch,\\n sgd=optimizer,\\n drop=next(dropout_rates),\\n losses=losses,\\n )\\n except ValueError as e:\\n err = \\\"Error during training\\\"\\n if init_tok2vec:\\n err += \\\" Did you provide the same parameters during 'train' as during 'pretrain'?\\\"\\n msg.fail(err, f\\\"Original error message: {e}\\\", exits=1)\\n if raw_text:\\n # If raw text is available, perform 'rehearsal' updates,\\n # which use unlabelled data to reduce overfitting.\\n raw_batch = list(next(raw_batches))\\n nlp.rehearse(raw_batch, sgd=optimizer, losses=losses)\\n docs = [ex.doc for ex in batch]\\n if not int(os.environ.get(\\\"LOG_FRIENDLY\\\", 0)):\\n pbar.update(sum(len(doc) for doc in docs))\\n words_seen += sum(len(doc) for doc in docs)\\n with nlp.use_params(optimizer.averages):\\n util.set_env_log(False)\\n epoch_model_path = output_path / f\\\"model{i}\\\"\\n nlp.to_disk(epoch_model_path)\\n nlp_loaded = util.load_model_from_path(epoch_model_path)\\n for beam_width in eval_beam_widths:\\n for name, component in nlp_loaded.pipeline:\\n if hasattr(component, \\\"cfg\\\"):\\n component.cfg[\\\"beam_width\\\"] = beam_width\\n dev_dataset = list(\\n corpus.dev_dataset(\\n nlp_loaded,\\n gold_preproc=gold_preproc,\\n ignore_misaligned=True,\\n )\\n )\\n nwords = sum(len(ex.doc) for ex in dev_dataset)\\n start_time = timer()\\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\\n end_time = timer()\\n if use_gpu < 0:\\n gpu_wps = None\\n cpu_wps = nwords / (end_time - start_time)\\n else:\\n gpu_wps = nwords / (end_time - start_time)\\n with use_ops(\\\"numpy\\\"):\\n nlp_loaded = util.load_model_from_path(epoch_model_path)\\n for name, component in nlp_loaded.pipeline:\\n if hasattr(component, \\\"cfg\\\"):\\n component.cfg[\\\"beam_width\\\"] = beam_width\\n dev_dataset = list(\\n corpus.dev_dataset(\\n nlp_loaded,\\n gold_preproc=gold_preproc,\\n ignore_misaligned=True,\\n )\\n )\\n start_time = timer()\\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\\n end_time = timer()\\n cpu_wps = nwords / (end_time - start_time)\\n acc_loc = output_path / f\\\"model{i}\\\" / \\\"accuracy.json\\\"\\n srsly.write_json(acc_loc, scorer.scores)\\n\\n # Update model meta.json\\n meta[\\\"lang\\\"] = nlp.lang\\n meta[\\\"pipeline\\\"] = nlp.pipe_names\\n meta[\\\"spacy_version\\\"] = f\\\">={about.__version__}\\\"\\n if beam_width == 1:\\n meta[\\\"speed\\\"] = {\\n \\\"nwords\\\": nwords,\\n \\\"cpu\\\": cpu_wps,\\n \\\"gpu\\\": gpu_wps,\\n }\\n meta.setdefault(\\\"accuracy\\\", {})\\n for component in nlp.pipe_names:\\n for metric in _get_metrics(component):\\n meta[\\\"accuracy\\\"][metric] = scorer.scores[metric]\\n else:\\n meta.setdefault(\\\"beam_accuracy\\\", {})\\n meta.setdefault(\\\"beam_speed\\\", {})\\n for component in nlp.pipe_names:\\n for metric in _get_metrics(component):\\n meta[\\\"beam_accuracy\\\"][metric] = scorer.scores[metric]\\n meta[\\\"beam_speed\\\"][beam_width] = {\\n \\\"nwords\\\": nwords,\\n \\\"cpu\\\": cpu_wps,\\n \\\"gpu\\\": gpu_wps,\\n }\\n meta[\\\"vectors\\\"] = {\\n \\\"width\\\": nlp.vocab.vectors_length,\\n \\\"vectors\\\": len(nlp.vocab.vectors),\\n \\\"keys\\\": nlp.vocab.vectors.n_keys,\\n \\\"name\\\": nlp.vocab.vectors.name,\\n }\\n meta.setdefault(\\\"name\\\", f\\\"model{i}\\\")\\n meta.setdefault(\\\"version\\\", version)\\n meta[\\\"labels\\\"] = nlp.meta[\\\"labels\\\"]\\n meta_loc = output_path / f\\\"model{i}\\\" / \\\"meta.json\\\"\\n srsly.write_json(meta_loc, meta)\\n util.set_env_log(verbose)\\n\\n progress = _get_progress(\\n i,\\n losses,\\n scorer.scores,\\n output_stats,\\n beam_width=beam_width if has_beam_widths else None,\\n cpu_wps=cpu_wps,\\n gpu_wps=gpu_wps,\\n )\\n if i == 0 and \\\"textcat\\\" in pipeline:\\n textcats_per_cat = scorer.scores.get(\\\"textcats_per_cat\\\", {})\\n for cat, cat_score in textcats_per_cat.items():\\n if cat_score.get(\\\"roc_auc_score\\\", 0) < 0:\\n msg.warn(\\n f\\\"Textcat ROC AUC score is undefined due to \\\"\\n f\\\"only one value in label '{cat}'.\\\"\\n )\\n msg.row(progress, **row_settings)\\n # Early stopping\\n if n_early_stopping is not None:\\n current_score = _score_for_model(meta)\\n if current_score < best_score:\\n iter_since_best += 1\\n else:\\n iter_since_best = 0\\n best_score = current_score\\n if iter_since_best >= n_early_stopping:\\n msg.text(\\n f\\\"Early stopping, best iteration is: {i - iter_since_best}\\\"\\n )\\n msg.text(\\n f\\\"Best score = {best_score}; Final iteration score = {current_score}\\\"\\n )\\n break\\n except Exception as e:\\n msg.warn(f\\\"Aborting and saving final best model. Encountered exception: {e}\\\")\\n finally:\\n best_pipes = nlp.pipe_names\\n if disabled_pipes:\\n disabled_pipes.restore()\\n with nlp.use_params(optimizer.averages):\\n final_model_path = output_path / \\\"model-final\\\"\\n nlp.to_disk(final_model_path)\\n meta_loc = output_path / \\\"model-final\\\" / \\\"meta.json\\\"\\n final_meta = srsly.read_json(meta_loc)\\n final_meta.setdefault(\\\"accuracy\\\", {})\\n final_meta[\\\"accuracy\\\"].update(meta.get(\\\"accuracy\\\", {}))\\n final_meta.setdefault(\\\"speed\\\", {})\\n final_meta[\\\"speed\\\"].setdefault(\\\"cpu\\\", None)\\n final_meta[\\\"speed\\\"].setdefault(\\\"gpu\\\", None)\\n meta.setdefault(\\\"speed\\\", {})\\n meta[\\\"speed\\\"].setdefault(\\\"cpu\\\", None)\\n meta[\\\"speed\\\"].setdefault(\\\"gpu\\\", None)\\n # combine cpu and gpu speeds with the base model speeds\\n if final_meta[\\\"speed\\\"][\\\"cpu\\\"] and meta[\\\"speed\\\"][\\\"cpu\\\"]:\\n speed = _get_total_speed(\\n [final_meta[\\\"speed\\\"][\\\"cpu\\\"], meta[\\\"speed\\\"][\\\"cpu\\\"]]\\n )\\n final_meta[\\\"speed\\\"][\\\"cpu\\\"] = speed\\n if final_meta[\\\"speed\\\"][\\\"gpu\\\"] and meta[\\\"speed\\\"][\\\"gpu\\\"]:\\n speed = _get_total_speed(\\n [final_meta[\\\"speed\\\"][\\\"gpu\\\"], meta[\\\"speed\\\"][\\\"gpu\\\"]]\\n )\\n final_meta[\\\"speed\\\"][\\\"gpu\\\"] = speed\\n # if there were no speeds to update, overwrite with meta\\n if (\\n final_meta[\\\"speed\\\"][\\\"cpu\\\"] is None\\n and final_meta[\\\"speed\\\"][\\\"gpu\\\"] is None\\n ):\\n final_meta[\\\"speed\\\"].update(meta[\\\"speed\\\"])\\n # note: beam speeds are not combined with the base model\\n if has_beam_widths:\\n final_meta.setdefault(\\\"beam_accuracy\\\", {})\\n final_meta[\\\"beam_accuracy\\\"].update(meta.get(\\\"beam_accuracy\\\", {}))\\n final_meta.setdefault(\\\"beam_speed\\\", {})\\n final_meta[\\\"beam_speed\\\"].update(meta.get(\\\"beam_speed\\\", {}))\\n srsly.write_json(meta_loc, final_meta)\\n msg.good(\\\"Saved model to output directory\\\", final_model_path)\\n with msg.loading(\\\"Creating best model...\\\"):\\n best_model_path = _collate_best_model(final_meta, output_path, best_pipes)\\n msg.good(\\\"Created best model\\\", best_model_path)\",\n \"def train(self, X_train, y_train):\\n\\n self.model_pipeline.fit(X_train, y_train)\",\n \"def train(self, features, labels):\\n pass\",\n \"def train(self, trnM, trnL):\\n print 'Training ...'\\n self.clf.fit(trnM, trnL)\",\n \"async def train(self):\",\n \"def train_start(self):\\n self.module.img_enc.train()\\n self.module.txt_enc.train()\",\n \"def model_fn(features,labels,mode,params):\\n tf.logging.info('*** Features ***')\\n for name in sorted(features.keys()):\\n tf.logging.info(\\\" name = %s ,shape = %s\\\" % (name,features[name].shape))\\n\\n input_ids = features['input_ids']\\n input_mask = features['input_mask']\\n segment_ids = features['segment_ids']\\n label_ids = features['label_ids']\\n if 'is_real_example' in features:\\n is_real_example = tf.cast(features['is_real_example'],dtype=tf.float32)\\n else:\\n is_real_example = tf.ones(tf.shape(label_ids),dtype=tf.float32)\\n\\n is_training = (mode == tf_estimator.estimator.ModeKeys.TRAIN)\\n\\n (total_loss,per_example_loss,probabilities,predictions) = \\\\\\n create_model(albert_config,is_training,input_ids,input_mask,\\n segment_ids,label_ids,num_labels,\\n use_one_hot_embeddings)\\n\\n tvars = tf.trainable_variables()\\n initialized_variable_names = {}\\n if init_checkpoint:\\n (assignment_map,initialized_variable_names) = modeling.get_assignment_map_from_checkpoint(tvars,init_checkpoint)\\n tf.train.init_from_checkpoint(init_checkpoint,assignment_map)\\n\\n tf.logging.info(\\\"**** Trainable Variables ****\\\")\\n for var in tvars:\\n init_string = \\\"\\\"\\n if var.name in initialized_variable_names:\\n init_string = \\\", *INIT_FROM_CKPT*\\\"\\n tf.logging.info(\\\" name = %s, shape = %s%s\\\", var.name, var.shape,\\n init_string)\\n\\n output_spec = None\\n if mode == tf_estimator.estimator.ModeKeys.TRAIN:\\n train_op = optimization.create_optimizer(total_loss,\\n learning_rate,\\n num_train_steps,\\n num_warmup_steps,use_tpu=False)\\n output_spec = tf_estimator.estimator.EstimatorSpec(\\n mode=mode,\\n loss=total_loss,\\n train_op=train_op,\\n )\\n elif mode == tf_estimator.estimator.ModeKeys.EVAL:\\n def metric_fn(per_example_loss,label_ids,logits,is_real_example):\\n accuracy = tf.metrics.accuracy(\\n labels=label_ids,predictions=predictions,\\n weights=is_real_example\\n )\\n loss = tf.metrics.mean(\\n values=per_example_loss,weights=is_real_example\\n )\\n return {\\n 'eval_accuracy':accuracy,\\n 'eval_loss':loss,\\n }\\n\\n eval_metrics = metric_fn(per_example_loss,label_ids,predictions,is_real_example)\\n output_spec = tf_estimator.estimator.EstimatorSpec(\\n mode=mode,\\n loss=total_loss,\\n eval_metric_ops=eval_metrics\\n )\\n else:\\n output_spec = tf_estimator.estimator.EstimatorSpec(\\n mode=mode,\\n predictions={\\n 'probabilities':probabilities,\\n 'predictions':predictions,\\n },\\n )\\n\\n return output_spec\",\n \"def train(self, opts):\\n with self._session.as_default(), self._session.graph.as_default():\\n self._train_internal(opts)\\n self._trained = True\",\n \"def train(model, train_inputs, train_labels):\\n print('Train starts: \\\\n')\\n indices = tf.range(0, train_inputs.shape[0])\\n indices = tf.random.shuffle(indices)\\n train_inputs = tf.gather(train_inputs, indices)\\n train_labels = tf.gather(train_labels, indices)\\n\\n N = train_inputs.shape[0] // model.batch_size\\n for batch in range(N):\\n start = batch * model.batch_size\\n end = (batch + 1) * model.batch_size\\n if (batch + 1) * model.batch_size > train_inputs.shape[0]:\\n end = train_inputs.shape[0]\\n inputs = train_inputs[start: end]\\n labels = train_labels[start: end]\\n\\n with tf.GradientTape() as tape:\\n probs = model.call(inputs)\\n loss = model.loss_function(probs, labels)\\n\\n gradients = tape.gradient(loss, model.trainable_variables)\\n model.optimizer.apply_gradients(zip(gradients, model.trainable_variables))\\n # if batch % 100 == 0:\\n # print('Batch {} starts:'.format(batch))\\n print('\\\\r', \\\"training processing : {} %\\\".format((batch + 1) * 100 // N), end='')\",\n \"def train(self):\\n train_dataloader = self.get_train_dataloader()\\n\\n if self.args.max_steps > 0:\\n t_total = self.args.max_steps\\n num_train_epochs = (\\n self.args.max_steps // (len(train_dataloader) // self.args.gradient_accumulation_steps) + 1\\n )\\n else:\\n t_total = int(len(train_dataloader) // self.args.gradient_accumulation_steps * self.args.num_train_epochs)\\n num_train_epochs = self.args.num_train_epochs\\n\\n lr_scheduler = orttrainer.optim.LinearWarmupLRScheduler(t_total, self.args.warmup_steps / float(t_total))\\n\\n loss_scaler = amp.DynamicLossScaler() if self.args.fp16 else None\\n device = self.args.device.type\\n\\n device = f\\\"{device}:{self.args.device.index}\\\" if self.args.device.index else f\\\"{device}:0\\\"\\n options = orttrainer.ORTTrainerOptions(\\n {\\n \\\"batch\\\": {\\\"gradient_accumulation_steps\\\": self.args.gradient_accumulation_steps},\\n \\\"device\\\": {\\\"id\\\": device},\\n \\\"mixed_precision\\\": {\\\"enabled\\\": self.args.fp16, \\\"loss_scaler\\\": loss_scaler},\\n \\\"debug\\\": {\\n \\\"deterministic_compute\\\": True,\\n },\\n \\\"utils\\\": {\\\"grad_norm_clip\\\": False},\\n \\\"distributed\\\": {\\n # we are running single node multi gpu test. thus world_rank = local_rank\\n # and world_size = self.args.n_gpu\\n \\\"world_rank\\\": max(0, self.args.local_rank),\\n \\\"world_size\\\": int(self.world_size),\\n \\\"local_rank\\\": max(0, self.args.local_rank),\\n \\\"allreduce_post_accumulation\\\": True,\\n },\\n \\\"lr_scheduler\\\": lr_scheduler,\\n }\\n )\\n\\n param_optimizer = list(self.model.named_parameters())\\n params = [\\n {\\n \\\"params\\\": [n for n, p in param_optimizer if \\\"bias\\\" in n or \\\"LayerNorm.weight\\\" in n],\\n \\\"weight_decay_mode\\\": 1,\\n },\\n {\\n \\\"params\\\": [n for n, p in param_optimizer if not (\\\"bias\\\" in n or \\\"LayerNorm.weight\\\" in n)],\\n \\\"weight_decay_mode\\\": 1,\\n },\\n ]\\n\\n optim_config = optim.AdamConfig(params=params, lr=2e-5, do_bias_correction=True)\\n self.model = orttrainer.ORTTrainer(self.model, self.model_desc, optim_config, options=options)\\n\\n # Train!\\n logger.info(\\\"***** Running training *****\\\")\\n logger.info(\\\" Num examples = %d\\\", len(train_dataloader.dataset))\\n logger.info(\\\" Num Epochs = %d\\\", num_train_epochs)\\n logger.info(\\\" Instantaneous batch size per GPU = %d\\\", self.args.per_gpu_train_batch_size)\\n logger.info(\\n \\\" Total train batch size (w. parallel, distributed & accumulation) = %d\\\",\\n self.args.train_batch_size\\n * self.args.gradient_accumulation_steps\\n * (torch.distributed.get_world_size() if self.args.local_rank != -1 else 1),\\n )\\n logger.info(\\\" Gradient Accumulation steps = %d\\\", self.args.gradient_accumulation_steps)\\n logger.info(\\\" Total optimization steps = %d\\\", t_total)\\n\\n global_step = 0\\n epochs_trained = 0\\n steps_trained_in_current_epoch = 0\\n\\n tr_loss = 0.0\\n logging_loss = 0.0\\n train_iterator = trange(\\n epochs_trained,\\n int(num_train_epochs),\\n desc=\\\"Epoch\\\",\\n disable=self.args.local_rank not in [-1, 0],\\n )\\n\\n for _epoch in train_iterator:\\n epoch_iterator = tqdm(train_dataloader, desc=\\\"Iteration\\\", disable=self.args.local_rank not in [-1, 0])\\n for step, inputs in enumerate(epoch_iterator):\\n # Skip past any already trained steps if resuming training\\n if steps_trained_in_current_epoch > 0:\\n steps_trained_in_current_epoch -= 1\\n continue\\n\\n tr_loss += self._training_step(self.model, inputs)\\n\\n if (step + 1) % self.args.gradient_accumulation_steps == 0 or (\\n len(epoch_iterator) <= self.args.gradient_accumulation_steps and (step + 1) == len(epoch_iterator)\\n ):\\n global_step += 1\\n\\n if self.args.local_rank in [-1, 0]:\\n if (self.args.logging_steps > 0 and global_step % self.args.logging_steps == 0) or (\\n global_step == 1 and self.args.logging_first_step\\n ):\\n logs = {}\\n if self.args.evaluate_during_training:\\n results = self.evaluate()\\n for key, value in results.items():\\n eval_key = f\\\"eval_{key}\\\"\\n logs[eval_key] = value\\n\\n loss_scalar = (tr_loss - logging_loss) / self.args.logging_steps\\n\\n logs[\\\"loss\\\"] = loss_scalar\\n logging_loss = tr_loss\\n\\n epoch_iterator.write(json.dumps({**logs, **{\\\"step\\\": global_step}}))\\n\\n if self.args.max_steps > 0 and global_step > self.args.max_steps:\\n epoch_iterator.close()\\n break\\n if self.args.max_steps > 0 and global_step > self.args.max_steps:\\n train_iterator.close()\\n break\\n\\n logger.info(\\\"\\\\n\\\\nTraining completed. \\\\n\\\\n\\\")\\n return TrainOutput(global_step, tr_loss / global_step)\",\n \"def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:\\n indexer = Indexer()\\n stop_words = set(stopwords.words('english'))\\n punkt = (',', '.', '...', '?', '\\\\'', '\\\\'\\\\'', '!', ':', ';')\\n # Initialize feature extractor\\n if args.model == \\\"TRIVIAL\\\":\\n feat_extractor = None\\n elif args.feats == \\\"UNIGRAM\\\":\\n # Generate vocabulary\\n for ex in train_exs:\\n for word in ex.words:\\n if word.lower() not in stop_words and word.lower() not in punkt:\\n indexer.add_and_get_index(word.lower())\\n feat_extractor = UnigramFeatureExtractor(indexer)\\n elif args.feats == \\\"BIGRAM\\\":\\n # Generate vocabulary\\n for ex in train_exs:\\n for i in range(0, len(ex.words) - 1):\\n if stop_words.__contains__(ex.words[i]) and stop_words.__contains__(ex.words[i + 1]) or (\\n punkt.__contains__(ex.words[i]) or punkt.__contains__(ex.words[i + 1])):\\n continue\\n bigram = ex.words[i] + ' ' + ex.words[i + 1]\\n indexer.add_and_get_index(bigram.lower())\\n feat_extractor = BigramFeatureExtractor(indexer)\\n elif args.feats == \\\"BETTER\\\":\\n # Generate vocabulary\\n cnt = Counter()\\n for ex in train_exs:\\n cnt.update(\\n word.lower() for word in ex.words if word.lower() not in stop_words and word.lower() not in punkt)\\n cnt = dict(cnt.most_common(int(cnt.__len__() * 0.75)))\\n for keys in cnt.keys():\\n indexer.add_and_get_index(keys)\\n feat_extractor = BetterFeatureExtractor(indexer)\\n else:\\n raise Exception(\\\"Pass in UNIGRAM, BIGRAM, or BETTER to run the appropriate system\\\")\\n\\n # Train the model\\n if args.model == \\\"TRIVIAL\\\":\\n model = TrivialSentimentClassifier()\\n elif args.model == \\\"PERCEPTRON\\\":\\n model = train_perceptron(train_exs, feat_extractor)\\n elif args.model == \\\"LR\\\":\\n model = train_logistic_regression(train_exs, feat_extractor)\\n else:\\n raise Exception(\\\"Pass in TRIVIAL, PERCEPTRON, or LR to run the appropriate system\\\")\\n return model\",\n \"def do_train_automl(**kwargs):\\n # instantiate automl client\\n automl_client = AutoMlClient()\\n\\n model_name = clv_automl.create_automl_model(automl_client,\\n PROJECT,\\n REGION,\\n DATASET,\\n 'features_n_target',\\n AUTOML_DATASET,\\n AUTOML_MODEL,\\n AUTOML_TRAINING_BUDGET)\\n clv_automl.deploy_model(automl_client, model_name)\",\n \"def train_text_model(train_dir, num_steps):\\n if tf.gfile.Exists(train_dir):\\n # Delete old model\\n tf.gfile.DeleteRecursively(train_dir)\\n tf.gfile.MakeDirs(train_dir)\\n\\n with tf.Graph().as_default():\\n model = TextModel(_CONFIG)\\n # Specify the loss function:\\n one_hot_labels = slim.one_hot_encoding(model.labels, model.nb_emotions)\\n slim.losses.softmax_cross_entropy(model.logits, one_hot_labels)\\n total_loss = slim.losses.get_total_loss()\\n\\n # Create some summaries to visualize the training process\\n # Use tensorboard --logdir=train_dir, careful with path (add Documents/tumblr-sentiment in front of train_dir)\\n # Different from the logs, because computed on different mini batch of data\\n tf.summary.scalar('Loss', total_loss)\\n \\n # Specify the optimizer and create the train op:\\n optimizer = tf.train.AdamOptimizer(learning_rate=model.learning_rate)\\n train_op = slim.learning.create_train_op(total_loss, optimizer)\\n\\n batch_size = _CONFIG['batch_size']\\n initial_lr = _CONFIG['initial_lr']\\n decay_factor = _CONFIG['decay_factor']\\n nb_batches = model.dataset.num_samples / batch_size\\n def train_step_fn(session, *args, **kwargs):\\n # Decaying learning rate every epoch\\n if train_step_fn.step % (nb_batches) == 0:\\n lr_decay = decay_factor ** train_step_fn.epoch\\n session.run(model.lr_rate_assign, feed_dict={model.lr_rate_placeholder: initial_lr * lr_decay})\\n print('New learning rate: {0}'. format(initial_lr * lr_decay))\\n train_step_fn.epoch += 1\\n\\n # Initialise embedding weights\\n if train_step_fn.step == 0:\\n session.run(model.embedding_init, feed_dict={model.embedding_placeholder: model.embedding})\\n total_loss, should_stop = train_step(session, *args, **kwargs)\\n\\n train_step_fn.step += 1\\n return [total_loss, should_stop]\\n \\n train_step_fn.step = 0\\n train_step_fn.epoch = 0\\n\\n # Run the training:\\n final_loss = slim.learning.train(\\n train_op,\\n logdir=train_dir,\\n save_interval_secs=600,\\n save_summaries_secs=600,\\n train_step_fn=train_step_fn,\\n number_of_steps=num_steps)\\n \\n print('Finished training. Last batch loss {0:.3f}'.format(final_loss))\",\n \"def train():\\n\\n dataset_train = SequenceDataset(\\n subset=\\\"train\\\",\\n config_dir=FLAGS.config_dir,\\n data_dir=FLAGS.data_dir,\\n batch_size=FLAGS.batch_size,\\n input_size=FLAGS.input_dim,\\n output_size=FLAGS.output_dim,\\n num_threads=FLAGS.num_threads,\\n use_bucket=True,\\n infer=False,\\n name=\\\"dataset_train\\\")()\\n\\n dataset_valid = SequenceDataset(\\n subset=\\\"valid\\\",\\n config_dir=FLAGS.config_dir,\\n data_dir=FLAGS.data_dir,\\n batch_size=FLAGS.batch_size,\\n input_size=FLAGS.input_dim,\\n output_size=FLAGS.output_dim,\\n num_threads=FLAGS.num_threads,\\n use_bucket=True,\\n infer=False,\\n name=\\\"dataset_valid\\\")()\\n\\n model = TfModel(\\n rnn_cell=FLAGS.rnn_cell,\\n dnn_depth=FLAGS.dnn_depth,\\n dnn_num_hidden=FLAGS.dnn_num_hidden,\\n rnn_depth=FLAGS.rnn_depth,\\n rnn_num_hidden=FLAGS.rnn_num_hidden,\\n output_size=FLAGS.output_dim,\\n bidirectional=FLAGS.bidirectional,\\n rnn_output=FLAGS.rnn_output,\\n cnn_output=FLAGS.cnn_output,\\n look_ahead=FLAGS.look_ahead,\\n mdn_output=FLAGS.mdn_output,\\n mix_num=FLAGS.mix_num,\\n name=\\\"tf_model\\\")\\n\\n # Build a reinitializable iterator for both dataset_train and dataset_valid.\\n iterator = tf.data.Iterator.from_structure(\\n dataset_train.batched_dataset.output_types,\\n dataset_train.batched_dataset.output_shapes)\\n (input_sequence, input_sequence_length,\\n target_sequence, target_sequence_length) = iterator.get_next()\\n\\n training_init_op = iterator.make_initializer(dataset_train.batched_dataset)\\n validation_init_op = iterator.make_initializer(dataset_valid.batched_dataset)\\n\\n # Build the model and get the loss.\\n output_sequence_logits, train_final_state = model(\\n input_sequence, input_sequence_length)\\n loss = model.loss(\\n output_sequence_logits, target_sequence, target_sequence_length)\\n tf.summary.scalar(\\\"loss\\\", loss)\\n\\n learning_rate = tf.get_variable(\\n \\\"learning_rate\\\",\\n shape=[],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(FLAGS.learning_rate),\\n trainable=False)\\n reduce_learning_rate = learning_rate.assign(\\n learning_rate * FLAGS.reduce_learning_rate_multiplier)\\n\\n global_step = tf.get_variable(\\n name=\\\"global_step\\\",\\n shape=[],\\n dtype=tf.int64,\\n initializer=tf.zeros_initializer(),\\n trainable=False,\\n collections=[tf.GraphKeys.GLOBAL_VARIABLES, tf.GraphKeys.GLOBAL_STEP])\\n\\n # Set up optimizer with global norm clipping.\\n trainable_variables = tf.trainable_variables()\\n optimizer = tf.train.AdamOptimizer(learning_rate)\\n grads, _ = tf.clip_by_global_norm(\\n tf.gradients(loss, trainable_variables),\\n FLAGS.max_grad_norm)\\n\\n train_step = optimizer.apply_gradients(\\n zip(grads, trainable_variables),\\n global_step=global_step)\\n\\n show_all_variables()\\n merged_all = tf.summary.merge_all()\\n saver = tf.train.Saver(max_to_keep=FLAGS.max_epochs)\\n\\n # Train\\n config = tf.ConfigProto()\\n # Prevent exhausting all the gpu memories\\n config.gpu_options.allow_growth = True\\n with tf.Session(config=config) as sess:\\n # Run init\\n sess.run(tf.global_variables_initializer())\\n\\n summary_writer = tf.summary.FileWriter(\\n os.path.join(FLAGS.save_dir, \\\"nnet\\\"), sess.graph)\\n\\n if FLAGS.resume_training:\\n restore_from_ckpt(sess, saver)\\n\\n # add a blank line for log readability\\n print()\\n sys.stdout.flush()\\n\\n sess.run(validation_init_op)\\n loss_prev = eval_one_epoch(sess, loss, dataset_valid.num_batches)\\n tf.logging.info(\\\"CROSSVAL PRERUN AVG.LOSS %.4f\\\\n\\\" % loss_prev)\\n\\n for epoch in range(FLAGS.max_epochs):\\n # Train one epoch\\n time_start = time.time()\\n sess.run(training_init_op)\\n tr_loss = train_one_epoch(sess, summary_writer, merged_all, global_step,\\n train_step, loss, dataset_train.num_batches)\\n time_end = time.time()\\n used_time = time_end - time_start\\n\\n # Validate one epoch\\n sess.run(validation_init_op)\\n val_loss = eval_one_epoch(sess, loss, dataset_valid.num_batches)\\n\\n # Determine checkpoint path\\n FLAGS.learning_rate = sess.run(learning_rate)\\n cptk_name = 'nnet_epoch%d_lrate%g_tr%.4f_cv%.4f' % (\\n epoch + 1, FLAGS.learning_rate, tr_loss, val_loss)\\n checkpoint_path = os.path.join(FLAGS.save_dir, \\\"nnet\\\", cptk_name)\\n\\n # accept or reject new parameters\\n if val_loss < loss_prev:\\n saver.save(sess, checkpoint_path)\\n # logging training loss along with validation loss\\n tf.logging.info(\\n \\\"EPOCH %d: TRAIN AVG.LOSS %.4f, (lrate%g) \\\"\\n \\\"CROSSVAL AVG.LOSS %.4f, TIME USED %.2f, %s\\\" % (\\n epoch + 1, tr_loss, FLAGS.learning_rate, val_loss,\\n used_time, \\\"nnet accepted\\\"))\\n loss_prev = val_loss\\n else:\\n tf.logging.info(\\n \\\"EPOCH %d: TRAIN AVG.LOSS %.4f, (lrate%g) \\\"\\n \\\"CROSSVAL AVG.LOSS %.4f, TIME USED %.2f, %s\\\" % (\\n epoch + 1, tr_loss, FLAGS.learning_rate, val_loss,\\n used_time, \\\"nnet rejected\\\"))\\n restore_from_ckpt(sess, saver)\\n # Reducing learning rate.\\n sess.run(reduce_learning_rate)\\n\\n # add a blank line for log readability\\n print()\\n sys.stdout.flush()\",\n \"def train(self, lib, service, model_name, algorithm, dataset_url, label, train_percentage, features,\\n save_model=True,\\n params=None):\\n url = self.base_url + '/ml-service/phoenix-ml/' + service + '/train'\\n headers = {\\\"ApiKey\\\": self.api_key, \\\"Content-type\\\": \\\"application/json\\\"}\\n if params is None:\\n params = {}\\n body = {\\n \\\"library\\\": lib,\\n \\\"task\\\": \\\"train\\\",\\n \\\"config\\\": {\\n \\\"name\\\": model_name,\\n \\\"algorithm\\\": algorithm,\\n \\\"datasetUrl\\\": dataset_url,\\n \\\"label\\\": label,\\n \\\"trainPercentage\\\": train_percentage,\\n \\\"features\\\": features,\\n \\\"saveModel\\\": save_model,\\n \\\"params\\\": params\\n }\\n }\\n response = requests.post(url=url, json=body, headers=headers)\\n response = response.json()\\n return response\",\n \"def train(self):\\n self.mode = \\\"train\\\"\\n self.online_net.train()\",\n \"def train(self):\\n self.mode = \\\"train\\\"\\n self.online_net.train()\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train_model(train: Train, tf: Featureset(\\\"transaction_features\\\")) -> Any:\\n\\n # We create the training and label data\\n train_df = tf.to_pandas()\\n X = train_df.drop([\\\"transactionId\\\", \\\"is_fraud\\\"], axis=1)\\n Y = train_df[\\\"is_fraud\\\"]\\n\\n random_state = 13\\n test_size = 0.2\\n train.log_parameter(\\\"random_state\\\", random_state)\\n train.log_parameter(\\\"test_size\\\", test_size)\\n trainX, testX, trainY, testY = train_test_split(X, Y, test_size=test_size,\\n random_state=random_state)\\n\\n # Here we register input & output of the train. Layer will use\\n # this registers to extract the signature of the model and calculate\\n # the drift\\n train.register_input(trainX)\\n train.register_output(trainY)\\n\\n max_depth = 3\\n objective = 'binary:logitraw'\\n train.log_parameter(\\\"max_depth\\\", max_depth)\\n train.log_parameter(\\\"objective\\\", objective)\\n\\n # Train model\\n param = {'max_depth': max_depth, 'objective': objective}\\n dtrain = xgb.DMatrix(trainX, label=trainY)\\n model_xg = xgb.train(param, dtrain)\\n\\n dtest = xgb.DMatrix(testX)\\n preds = model_xg.predict(dtest)\\n\\n # Since the data is highly skewed, we will use the area under the\\n # precision-recall curve (AUPRC) rather than the conventional area under\\n # the receiver operating characteristic (AUROC). This is because the AUPRC\\n # is more sensitive to differences between algorithms and their parameter\\n # settings rather than the AUROC (see Davis and Goadrich,\\n # 2006: http://pages.cs.wisc.edu/~jdavis/davisgoadrichcamera2.pdf)\\n auprc = average_precision_score(testY, preds)\\n train.log_metric(\\\"auprc\\\", auprc)\\n\\n # We return the model\\n return model_xg\",\n \"def train():\\n args = arguments_st_train()\\n\\n h, w = map(int, args.input_size.split(','))\\n input_size = (h, w)\\n\\n \\n if args.use_random_seed:\\n tf.set_random_seed(args.random_seed)\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n \\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader(\\n args.data_dir,\\n args.data_list,\\n input_size=input_size,\\n random_scale=args.random_scale,\\n random_mirror=args.random_mirror,\\n random_crop=args.random_crop,\\n ignore_label=args.ignore_label,\\n img_mean=IMG_MEAN,\\n coord=coord,\\n task=args.task)\\n image_batch, label_batch = reader.dequeue(args.batch_size)\\n \\n # Create network.\\n with slim.arg_scope(vgg_arg_scope(weight_decay=args.weight_decay, use_batch_norm=True, is_training=True)):\\n if args.network == 'vgg_16_deeplab_st':\\n net, end_points = vgg_16_deeplab_st(image_batch, num_classes=args.num_classes, is_training=True, dropout_keep_prob=args.keep_prob)\\n elif args.network == 'vgg_16_shortcut_deeplab_st':\\n net, end_points = vgg_16_shortcut_deeplab_st(image_batch, num_classes=args.num_classes, is_training=True, dropout_keep_prob=args.keep_prob)\\n else:\\n raise Exception('network name is not recognized!')\\n \\n \\n # Predictions.\\n raw_output = end_points['vgg_16/fc8_voc12']\\n\\n # gt labels\\n raw_gt = prepare_label(label_batch, tf.stack(raw_output.get_shape()[1:3]), num_classes=args.num_classes,\\n one_hot=False, task=args.task) # [batch_size, h, w]\\n\\n # losses\\n if args.task == 'normal':\\n loss = get_normal_loss(raw_output, raw_gt, args.num_classes, args.ignore_label) * args.loss_scale\\n elif args.task == 'seg':\\n loss = get_seg_loss(raw_output, raw_gt, args.num_classes, args.ignore_label) * args.loss_scale\\n\\n l2_losses = [args.weight_decay * tf.nn.l2_loss(v) for v in tf.trainable_variables() if 'weights' in v.name]\\n reduced_loss = tf.reduce_mean(loss) + tf.add_n(l2_losses)\\n \\n # Image summary for visualisation.\\n raw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\\n raw_output_up = tf.argmax(raw_output_up, axis=3)\\n pred = tf.expand_dims(raw_output_up, dim=3)\\n \\n images_summary = tf.py_func(inv_preprocess, [image_batch, args.save_num_images, IMG_MEAN], tf.uint8)\\n labels_summary = tf.py_func(decode_labels, [label_batch, args.save_num_images, args.num_classes, args.task], tf.uint8)\\n preds_summary = tf.py_func(decode_labels, [pred, args.save_num_images, args.num_classes, args.task], tf.uint8)\\n \\n total_summary = tf.summary.image('images', \\n tf.concat(axis=2, values=[images_summary, labels_summary, preds_summary]), \\n max_outputs=args.save_num_images) # Concatenate row-wise.\\n summary_writer = tf.summary.FileWriter(args.snapshot_dir,\\n graph=tf.get_default_graph())\\n \\n # Define loss and optimisation parameters.\\n train_op, step_ph = create_train_ops_st(reduced_loss, args)\\n \\n # Set up tf session and initialize variables. \\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n \\n sess.run(init)\\n\\n # Load variables if the checkpoint is provided.\\n if args.restore_from is not None:\\n load_st(sess, args)\\n \\n # Saver for storing checkpoints of the model.\\n save_op = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=args.max_to_keep)\\n \\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n\\n # Iterate over training steps.\\n for step in range(args.num_steps):\\n start_time = time.time()\\n feed_dict = { step_ph : step }\\n \\n if step % args.save_pred_every == 0:\\n loss_value, images, labels, preds, summary, _ = sess.run([reduced_loss, image_batch, label_batch, pred, total_summary, train_op], feed_dict=feed_dict)\\n summary_writer.add_summary(summary, step)\\n save(save_op, sess, args.snapshot_dir, step)\\n else:\\n loss_value, _ = sess.run([reduced_loss, train_op], feed_dict=feed_dict)\\n duration = time.time() - start_time\\n print('step {:d} \\\\t loss = {:.3f}, ({:.3f} sec/step)'.format(step, loss_value, duration))\\n coord.request_stop()\\n coord.join(threads)\",\n \"def train(self, train_set, model_tf, model_af, num_epochs=5, resume=False, dev_set=None):\\n\\n\\t\\ttorch.cuda.empty_cache()\\n\\t\\tself.resume = resume\\n\\t\\tif resume:\\n\\n\\t\\t\\t# ------------------------------------------------------------------------------------\\n\\t\\t\\t# -------------------------- teacher forcing model resume ... \\n\\t\\t\\tlatest_checkpoint_path_tf = Checkpoint.get_latest_epoch_checkpoint(self.load_dir_tf)\\n\\t\\t\\tprint('resuming teacher forcing model {} ...'.format(latest_checkpoint_path_tf))\\n\\t\\t\\tresume_checkpoint_tf = Checkpoint.load(latest_checkpoint_path_tf)\\n\\t\\t\\tmodel_tf = resume_checkpoint_tf.model\\n\\t\\t\\tself.optimizer_tf = resume_checkpoint_tf.optimizer\\n\\n\\t\\t\\t# check var\\n\\t\\t\\tmodel_tf.set_var('attention_forcing', False)\\n\\t\\t\\tmodel_tf.set_var('debug_count', 0)\\n\\t\\t\\tmodel_tf.reset_use_gpu(self.use_gpu)\\n\\t\\t\\tmodel_tf.to(device)\\n\\t\\t\\tprint('attention forcing: {}'.format(model_tf.attention_forcing))\\n\\t\\t\\tprint('use gpu: {}'.format(model_tf.use_gpu))\\n\\n\\t\\t\\t# A walk around to set optimizing parameters properly\\n\\t\\t\\tresume_optim_tf = self.optimizer_tf.optimizer\\n\\t\\t\\tdefaults_tf = resume_optim_tf.param_groups[0]\\n\\t\\t\\tdefaults_tf.pop('params', None)\\n\\t\\t\\tdefaults_tf.pop('initial_lr', None)\\n\\t\\t\\tself.optimizer_tf.optimizer = resume_optim_tf.__class__(model_tf.parameters(), **defaults_tf)\\n\\n\\t\\t\\t# ------------------------------------------------------------------------------------\\n\\t\\t\\t# ----------------------------- attention forcing model resume ... \\n\\t\\t\\tlatest_checkpoint_path_af = Checkpoint.get_latest_epoch_checkpoint(self.load_dir_af)\\n\\t\\t\\tprint('resuming attention forcing model {} ...'.format(latest_checkpoint_path_af))\\n\\t\\t\\tresume_checkpoint_af = Checkpoint.load(latest_checkpoint_path_af)\\n\\t\\t\\tmodel_af = resume_checkpoint_af.model\\n\\t\\t\\tself.optimizer_af = resume_checkpoint_af.optimizer\\n\\n\\t\\t\\t# check var\\n\\t\\t\\tmodel_af.set_var('attention_forcing', True)\\n\\t\\t\\tmodel_af.set_var('debug_count', 0)\\n\\t\\t\\tmodel_af.reset_use_gpu(self.use_gpu)\\n\\t\\t\\tmodel_af.to(device)\\n\\t\\t\\tprint('attention forcing: {}'.format(model_af.attention_forcing))\\n\\t\\t\\tprint('use gpu: {}'.format(model_af.use_gpu))\\n\\n\\t\\t\\t# A walk around to set optimizing parameters properly\\n\\t\\t\\tresume_optim_af = self.optimizer_af.optimizer\\n\\t\\t\\tdefaults_af = resume_optim_af.param_groups[0]\\n\\t\\t\\tdefaults_af.pop('params', None)\\n\\t\\t\\tdefaults_af.pop('initial_lr', None)\\n\\t\\t\\tself.optimizer_af.optimizer = resume_optim_af.__class__(model_af.parameters(), **defaults_af)\\n\\n\\t\\t\\t# ------------------------------------------\\n\\t\\t\\tstart_epoch = resume_checkpoint_af.epoch\\n\\t\\t\\tstep = resume_checkpoint_af.step\\n\\n\\t\\telse:\\n\\t\\t\\tstart_epoch = 1\\n\\t\\t\\tstep = 0\\n\\n\\t\\t\\tlog = self.logger.info(\\\"------ teacher forcing model ------ \\\")\\n\\t\\t\\tfor name, param in model_tf.named_parameters():\\n\\t\\t\\t\\tlog = self.logger.info('{}:{}'.format(name, param.size()))\\n\\t\\t\\tlog = self.logger.info(\\\"------ attention forcing model ------ \\\")\\n\\t\\t\\tfor name, param in model_af.named_parameters():\\n\\t\\t\\t\\tlog = self.logger.info('{}:{}'.format(name, param.size()))\\n\\t\\t\\t\\t# check embedder init\\n\\t\\t\\t\\t# if 'embedder' in name:\\n\\t\\t\\t\\t# \\tprint('{}:{}'.format(name, param[5]))\\n\\n\\t\\t\\toptimizer_tf = Optimizer(torch.optim.Adam(model_tf.parameters(), \\n\\t\\t\\t\\t\\t\\tlr=self.learning_rate), max_grad_norm=self.max_grad_norm) # 5 -> 1\\n\\t\\t\\toptimizer_af = Optimizer(torch.optim.Adam(model_af.parameters(), \\n\\t\\t\\t\\t\\t\\tlr=self.learning_rate), max_grad_norm=self.max_grad_norm) # 5 -> 1\\n\\t\\t\\tself.optimizer_tf = optimizer_tf # teacher forcing\\n\\t\\t\\tself.optimizer_af = optimizer_af # attention forcing\\n\\n\\t\\tself.logger.info(\\\"TF Optimizer: %s, Scheduler: %s\\\" % (self.optimizer_tf.optimizer, self.optimizer_tf.scheduler))\\n\\t\\tself.logger.info(\\\"AF Optimizer: %s, Scheduler: %s\\\" % (self.optimizer_af.optimizer, self.optimizer_af.scheduler))\\n\\n\\t\\tself._train_epoches(train_set, model_tf, model_af, num_epochs, start_epoch, step, dev_set=dev_set)\\n\\t\\t\\n\\t\\treturn model_tf, model_af\",\n \"def trainNet():\",\n \"def train(self, request):\\n model = request.get(\\\"model\\\")\\n if not model:\\n raise MONAILabelException(\\n MONAILabelError.INVALID_INPUT,\\n \\\"Model is not provided for Training Task\\\",\\n )\\n\\n task = self._trainers.get(model)\\n if not task:\\n raise MONAILabelException(\\n MONAILabelError.INVALID_INPUT,\\n f\\\"Train Task is not Initialized. There is no model '{model}' available\\\",\\n )\\n\\n request = copy.deepcopy(request)\\n result = task(request, self.datastore())\\n\\n # Run all scoring methods\\n if self._auto_update_scoring:\\n self.async_scoring(None)\\n return result\",\n \"def train(self, features, actions, rewards):\\n self.model.fit(x=features, y=actions, sample_weight=rewards,\\n verbose=False)\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def train(self, sess):\\n assert self.mode == tf.contrib.learn.ModeKeys.TRAIN\\n return sess.run([self.update,\\n self.train_loss,\\n self.global_step,\\n self.train_summary])\",\n \"def training(self):\\n self.model.fit(self.train_x, self.train_y)\",\n \"def train():\\n with tf.Graph().as_default():\\n global_step = tf.contrib.framework.get_or_create_global_step()\\n\\n # Get images and labels for ocr.\\n print(\\\"Preparing input\\\")\\n # with tf.device('/cpu:0'):\\n images, labels, seq_lengths = ocr.distorted_inputs()\\n\\n # Build a Graph that computes the logits predictions from the\\n # inference model.\\n print(\\\"Building graph\\\")\\n logits, timesteps = ocr.inference(images, FLAGS.batch_size, train=True)\\n\\n # Calculate loss.\\n print(\\\"Creating loss\\\") \\n loss = ocr.create_ctc_loss(logits, labels, timesteps, seq_lengths)\\n\\n print(\\\"Creating LER\\\")\\n ler = ocr.create_label_error_rate(logits, labels, timesteps)\\n\\n print(\\\"Creating decoder\\\")\\n decoded = ocr.check_decoder(logits, labels, timesteps)\\n\\n # Build a Graph that trains the model with one batch of examples and\\n # updates the model parameters.\\n print(\\\"Creating train OP\\\")\\n train_op, lr = ocr.train_simple(loss, global_step)\\n\\n print(\\\"Creating init OP\\\")\\n init_op = tf.group(tf.global_variables_initializer(),\\n tf.local_variables_initializer())\\n\\n sess = tf.Session()\\n\\n sess.run(init_op)\\n\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n \\n train_writer = tf.summary.FileWriter(FLAGS.train_dir,\\n sess.graph)\\n saver = tf.train.Saver()\\n summary_op = tf.summary.merge_all()\\n\\n print(\\\"Starting training\\\")\\n print_every_n = 1000\\n start_time = time.time()\\n mean_ler = 0\\n while not coord.should_stop():\\n try: \\n _, loss_res, lr_res, ler_res, summary_op_result, global_step_result, decoded_res = sess.run([train_op, loss, lr, ler, summary_op, global_step, decoded])\\n mean_ler += ler_res\\n if global_step_result % print_every_n == 0 or global_step_result == 1:\\n mean_steps_time = (time.time() - start_time) / print_every_n\\n mean_ler = mean_ler / print_every_n\\n status_string = \\\"Step: {} Loss: {:.4f} LR: {:.6f} LER: {:.4f} Step time: {:.3f} sec\\\"\\n print(status_string.format(global_step_result, loss_res, lr_res, ler_res, mean_steps_time)) \\n # print(\\\"Decoded:\\\")\\n # print(str(decoded_res))\\n # print(\\\"Timesteps:\\\" + str(timesteps_res))\\n train_writer.add_summary(summary_op_result, global_step=global_step_result)\\n saver.save(sess, os.path.join(FLAGS.train_dir, 'checkpoint'), global_step=global_step)\\n start_time = time.time()\\n mean_ler = 0\\n\\n # images_res = sess.run(images)\\n # print(images_res) \\n # for img in images_res:\\n # cv2.imshow(\\\"img\\\", img)\\n # cv2.waitKey(0)\\n except Exception as e:\\n print(e)\\n coord.request_stop(e)\\n\\n # class _LoggerHook(tf.train.SessionRunHook):\\n # \\\"\\\"\\\"Logs loss and runtime.\\\"\\\"\\\"\\n #\\n # def begin(self):\\n # self._step = -1\\n #\\n # def before_run(self, run_context):\\n # self._step += 1\\n # self._start_time = time.time()\\n # return tf.train.SessionRunArgs(loss) # Asks for loss value.\\n #\\n # def after_run(self, run_context, run_values):\\n # duration = time.time() - self._start_time\\n # loss_value = run_values.results\\n # if self._step % 10 == 0:\\n # num_examples_per_step = FLAGS.batch_size\\n # examples_per_sec = num_examples_per_step / duration\\n # sec_per_batch = float(duration)\\n #\\n # format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '\\n # 'sec/batch)')\\n # print (format_str % (datetime.now(), self._step, loss_value,\\n # examples_per_sec, sec_per_batch))\\n #\\n # with tf.train.MonitoredTrainingSession(\\n # checkpoint_dir=FLAGS.train_dir,\\n # hooks=[tf.train.StopAtStepHook(last_step=FLAGS.max_steps),\\n # tf.train.NanTensorHook(loss),\\n # _LoggerHook()],\\n # config=tf.ConfigProto(\\n # log_device_placement=FLAGS.log_device_placement)) as mon_sess:\\n # while not mon_sess.should_stop():\\n # print(\\\"Running session\\\")\\n # mon_sess.run(train_op)\",\n \"def build_train_model(hparams,\\n scope=\\\"train\\\"):\\n src_lang = hparams.src_lang\\n src_vocab_file_name = hparams.src_vocab_file_name\\n tgt_lang = hparams.tgt_lang\\n tgt_vocab_file_name = hparams.tgt_vocab_file_name\\n\\n\\n\\n tf.reset_default_graph()\\n\\n train_graph = tf.Graph()\\n with train_graph.as_default() as g:\\n with tf.container(scope):\\n src_vocab, tgt_vocab = load_vocabs(src_lang, src_vocab_file_name,\\n tgt_lang, tgt_vocab_file_name)\\n src_dataset_file_name = tf.placeholder(tf.string, name=\\\"src_dataset_file_name\\\")\\n tgt_dataset_file_name = tf.placeholder(tf.string, name=\\\"tgt_dataset_file_name\\\")\\n\\n src_dataset = tf.data.TextLineDataset(src_dataset_file_name)\\n tgt_dataset = tf.data.TextLineDataset(tgt_dataset_file_name)\\n\\n batch_size = tf.placeholder(tf.int64, name=\\\"batch_size\\\")\\n\\n # maximum sequence length for training example\\n max_len = tf.placeholder(tf.int64, name=\\\"max_len\\\")\\n\\n iterator = Iterator(src_dataset, src_vocab,\\n tgt_dataset, tgt_vocab, batch_size=batch_size, max_len=max_len)\\n\\n # actual TensorFlow Dataset Iterator\\n iterator_tf = iterator.create_iterator()\\n\\n model_class = _get_model_from_str_type(hparams.model_name)\\n\\n model = model_class(hparams, src_vocab, tgt_vocab)\\n\\n model_graph = model.build_graph(iterator_tf,\\n tf.contrib.learn.ModeKeys.TRAIN, batch_size, g)\\n\\n return NTModel(src_vocab=src_vocab,\\n tgt_vocab=tgt_vocab,\\n iterator_tf=iterator_tf,\\n model_graph=model_graph,\\n model=model,\\n hparams=hparams,\\n mode=tf.contrib.learn.ModeKeys.TRAIN)\",\n \"def model_fn(features, labels, mode, params):\\n # obtain the data\\n _info('*** Features ***')\\n for name in sorted(features.keys()):\\n tf.logging.info(\\\" name = %s, shape = %s\\\" % (name, features[name].shape))\\n\\n input_ids = features['input_ids'] # [batch_size, seq_length]\\n input_mask = features['input_mask'] # [batch_size, seq_length]\\n\\n # if mode != tf.estimator.ModeKeys.PREDICT:\\n # # segment_idx = features['segment_dis']\\n # masked_lm_positions = features['masked_lm_positions'] # [batch_size, seq_length], specify the answer\\n # masked_lm_ids = features['masked_lm_ids'] # [batch_size, answer_seq_length], specify the answer labels\\n # masked_lm_weights = features['masked_lm_weights'] # [batch_size, seq_length], [1, 1, 0], 0 refers to the mask\\n # # next_sentence_labels = features['next_sentence_labels']\\n # else:\\n masked_lm_positions = features['masked_lm_positions']\\n masked_lm_ids = features['masked_lm_ids']\\n masked_lm_weights = features['masked_lm_weights']\\n\\n if bert_config.train_type == 'seq2seq':\\n _info('Training seq2seq task.')\\n elif bert_config.train_type == 'lm':\\n _info('Training language model task.')\\n \\n # build model\\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\\n model = BertModel(\\n config=bert_config,\\n is_training=is_training,\\n input_ids=input_ids,\\n input_mask=input_mask)\\n \\n # compute loss\\n loss, per_loss, log_probs, logits = get_masked_lm_output(bert_config,\\n model.get_sequence_output(),\\n model.embedding_table,\\n model.projection_table,\\n masked_lm_positions,\\n masked_lm_ids,\\n masked_lm_weights,\\n mode)\\n \\n if mode == tf.estimator.ModeKeys.PREDICT:\\n masked_lm_predictions = tf.reshape(tf.argmax(log_probs, axis=-1, output_type=tf.int32), [-1])\\n output_spec = tf.estimator.EstimatorSpec(mode, predictions=masked_lm_predictions)\\n else:\\n if mode == tf.estimator.ModeKeys.TRAIN: \\n # restore from the checkpoint,\\n # tf.estimator automatically restore from the model typically,\\n # maybe here is for restore some pre-trained parameters\\n tvars = tf.trainable_variables()\\n initialized_variable_names = {}\\n if init_checkpoint:\\n (assignment_map, initialized_variable_names) = get_assignment_map_from_checkpoint(tvars, init_checkpoint)\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n\\n _info('*** Trainable Variables ***')\\n for var in tvars:\\n init_string = ''\\n if var.name in initialized_variable_names:\\n init_string = ', *INIT_FROM_CKPT*'\\n _info('name = {}, shape={}{}'.format(var.name, var.shape, init_string))\\n \\n train_op = optimization.create_optimizer(\\n loss, bert_config.learning_rate, num_train_steps, bert_config.lr_limit)\\n\\n # learning_rate = tf.train.polynomial_decay(bert_config.learning_rate,\\n # tf.train.get_or_create_global_step(),\\n # num_train_steps,\\n # end_learning_rate=0.0,\\n # power=1.0,\\n # cycle=False)\\n # optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)\\n # gradients = tf.gradients(loss, tvars, colocate_gradients_with_ops=True)\\n # clipped_gradients, _ = tf.clip_by_global_norm(gradients, 5.0)\\n # train_op = optimizer.apply_gradients(zip(clipped_gradients, tvars), global_step=tf.train.get_global_step())\\n output_spec = tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)\\n elif mode == tf.estimator.ModeKeys.EVAL:\\n is_real_example = tf.ones(tf.shape(masked_lm_ids), dtype=tf.float32)\\n \\n def metric_fn(loss, label_ids, logits, is_real_example):\\n \\\"\\\"\\\"\\n Args:\\n loss: tf.float32.\\n label_ids: [b, s].\\n logits: [b, s, v].\\n \\\"\\\"\\\"\\n # [b * s, v]\\n logits = tf.reshape(logits, [-1, logits.shape[-1]])\\n # [b * s, 1]\\n predictions = tf.argmax(logits, axis=-1, output_type=tf.int32)\\n # [b * s]\\n label_ids = tf.reshape(label_ids, [-1])\\n accuracy = tf.metrics.accuracy(\\n labels=label_ids, predictions=predictions)\\n loss = tf.metrics.mean(values=loss)\\n return {'eval_accuracy': accuracy, 'eval_loss': loss}\\n \\n eval_metrics = metric_fn(loss, masked_lm_ids, logits, is_real_example)\\n output_spec = tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metrics)\\n\\n return output_spec\",\n \"def train(args):\\n \\n\\n train_generator, validation_generator, num_training, num_validation, num_classes = generate(args)\\n print(\\\"{} classes found\\\".format(num_classes))\\n\\n model = MobileNetV2((args.input_size, args.input_size, 3), num_classes, args.plot_model)\\n\\n opt = tf.keras.optimizers.Adam()\\n earlystop = tf.keras.callbacks.EarlyStopping(monitor='val_acc', patience=30, verbose=1, mode='auto')\\n model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['acc'])\\n\\n hist = model.fit_generator(\\n train_generator,\\n validation_data=validation_generator,\\n steps_per_epoch=num_training // args.batch_size,\\n validation_steps=num_validation // args.batch_size,\\n epochs=args.epochs,\\n callbacks=[earlystop])\\n\\n if not os.path.exists('model'):\\n os.makedirs('model')\\n\\n df = pd.DataFrame.from_dict(hist.history)\\n df.to_csv('model/hist.csv', encoding='utf-8', index=False)\\n if not os.path.exists('model/output'):\\n os.makedirs('model/output')\\n model.save('model/output')\",\n \"def train(self, dataset, model_dir):\\n raise NotImplementedError\",\n \"def train(log_dir):\\n\\n # Create train and test environments\\n print(\\n colorize(\\n f\\\"INFO: You are training in the {ENV_NAME} environment.\\\",\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n env = get_env_from_name(ENV_NAME, ENV_SEED)\\n test_env = get_env_from_name(ENV_NAME, ENV_SEED)\\n\\n # Set initial learning rates\\n lr_a, lr_l, lr_c = (\\n ALG_PARAMS[\\\"lr_a\\\"],\\n ALG_PARAMS[\\\"lr_l\\\"],\\n ALG_PARAMS[\\\"lr_c\\\"],\\n )\\n lr_a_now = ALG_PARAMS[\\\"lr_a\\\"] # learning rate for actor, lambda and alpha\\n lr_l_now = ALG_PARAMS[\\\"lr_l\\\"] # learning rate for Lyapunov critic\\n lr_c_now = ALG_PARAMS[\\\"lr_c\\\"] # learning rate for q critic\\n\\n # Get observation and action space dimension and limits from the environment\\n s_dim = env.observation_space.shape[0]\\n a_dim = env.action_space.shape[0]\\n a_lowerbound = env.action_space.low\\n a_upperbound = env.action_space.high\\n\\n # Create the Agent\\n policy = LAC(a_dim, s_dim, act_limits={\\\"low\\\": a_lowerbound, \\\"high\\\": a_upperbound})\\n\\n # Load model if retraining is selected\\n if TRAIN_PARAMS[\\\"continue_training\\\"]:\\n\\n # Create retrain model path\\n retrain_model_folder = TRAIN_PARAMS[\\\"continue_model_folder\\\"]\\n retrain_model_path = osp.abspath(\\n osp.join(log_dir, \\\"../..\\\", TRAIN_PARAMS[\\\"continue_model_folder\\\"])\\n )\\n\\n # Check if retrain model exists if not throw error\\n if not osp.exists(retrain_model_path):\\n print(\\n colorize(\\n (\\n \\\"ERROR: Shutting down training since the model you specified \\\"\\n f\\\"in the `continue_model_folder` `{retrain_model_folder}` \\\"\\n f\\\"argument was not found for the `{ENV_NAME}` environment.\\\"\\n ),\\n \\\"red\\\",\\n bold=True,\\n )\\n )\\n sys.exit(0)\\n\\n # Load old model\\n print(\\n colorize(\\n f\\\"INFO: Restoring model `{retrain_model_path}`.\\\", \\\"cyan\\\", bold=True\\n )\\n )\\n result = policy.restore(\\n osp.abspath(osp.join(retrain_model_path, \\\"policy\\\")),\\n restore_lagrance_multipliers=(not ALG_PARAMS[\\\"reset_lagrance_multipliers\\\"]),\\n )\\n if not result:\\n print(\\n colorize(\\n \\\"ERROR: Shuting down training as something went wrong while \\\"\\n \\\"loading \\\"\\n f\\\"model `{retrain_model_folder}`.\\\",\\n \\\"red\\\",\\n bold=True,\\n )\\n )\\n sys.exit(0)\\n\\n # Create new storage folder\\n log_dir_split = log_dir.split(\\\"/\\\")\\n log_dir_split[-2] = (\\n \\\"_\\\".join(TRAIN_PARAMS[\\\"continue_model_folder\\\"].split(\\\"/\\\")) + \\\"_finetune\\\"\\n )\\n log_dir = \\\"/\\\".join(log_dir_split)\\n else:\\n print(colorize(f\\\"INFO: Train new model `{log_dir}`\\\", \\\"cyan\\\", bold=True))\\n\\n # Print logging folder path\\n print(colorize(f\\\"INFO: Logging results to `{log_dir}`.\\\", \\\"cyan\\\", bold=True))\\n\\n # Create replay memory buffer\\n pool = Pool(\\n s_dim=s_dim,\\n a_dim=a_dim,\\n store_last_n_paths=TRAIN_PARAMS[\\\"num_of_training_paths\\\"],\\n memory_capacity=ALG_PARAMS[\\\"memory_capacity\\\"],\\n min_memory_size=ALG_PARAMS[\\\"min_memory_size\\\"],\\n )\\n\\n # Setup logger and log hyperparameters\\n logger.configure(dir=log_dir, format_strs=[\\\"csv\\\"])\\n logger.logkv(\\\"tau\\\", ALG_PARAMS[\\\"tau\\\"])\\n logger.logkv(\\\"alpha3\\\", ALG_PARAMS[\\\"alpha3\\\"])\\n logger.logkv(\\\"batch_size\\\", ALG_PARAMS[\\\"batch_size\\\"])\\n logger.logkv(\\\"target_entropy\\\", policy.target_entropy)\\n\\n ####################################################\\n # Training loop ####################################\\n ####################################################\\n\\n # Setup training loop parameters\\n t1 = time.time()\\n global_step = 0\\n global_episodes = 0\\n last_training_paths = deque(maxlen=TRAIN_PARAMS[\\\"num_of_training_paths\\\"])\\n training_started = False\\n\\n # Train the agent in the environment until max_episodes has been reached\\n print(colorize(\\\"INFO: Training...\\\\n\\\", \\\"cyan\\\", bold=True))\\n while 1: # Keep running episodes until global step has been reached\\n\\n # Create variable to store information about the current path\\n if policy.use_lyapunov:\\n current_path = {\\n \\\"rewards\\\": [],\\n \\\"lyapunov_error\\\": [],\\n \\\"alpha\\\": [],\\n \\\"lambda\\\": [],\\n \\\"entropy\\\": [],\\n \\\"a_loss\\\": [],\\n \\\"alpha_loss\\\": [],\\n \\\"lambda_loss\\\": [],\\n }\\n else:\\n current_path = {\\n \\\"rewards\\\": [],\\n \\\"critic_error\\\": [],\\n \\\"alpha\\\": [],\\n \\\"entropy\\\": [],\\n \\\"a_loss\\\": [],\\n \\\"alpha_loss\\\": [],\\n }\\n\\n # Reset environment\\n s = env.reset()\\n\\n # Training Episode loop\\n for jj in range(ENVS_PARAMS[ENV_NAME][\\\"max_ep_steps\\\"]):\\n\\n # Break out of loop if global steps have been reached\\n if global_step >= TRAIN_PARAMS[\\\"max_global_steps\\\"]:\\n\\n # Print step count, save model and stop the program\\n print(\\n colorize(\\n f\\\"\\\\nINFO: Training stopped after {global_step} steps.\\\",\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n print(\\n colorize(\\n \\\"INFO: Running time: {}\\\".format(time.time() - t1),\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n print(colorize(\\\"INFO: Saving Model\\\", \\\"cyan\\\", bold=True))\\n policy.save_result(log_dir)\\n return\\n\\n # Save intermediate checkpoints if requested\\n if TRAIN_PARAMS[\\\"save_checkpoints\\\"]:\\n if (\\n global_step % TRAIN_PARAMS[\\\"checkpoint_save_freq\\\"] == 0\\n and global_step != 0\\n ):\\n\\n # Create intermediate result checkpoint folder\\n checkpoint_save_path = osp.abspath(\\n osp.join(log_dir, \\\"checkpoints\\\", \\\"step_\\\" + str(jj))\\n )\\n os.makedirs(checkpoint_save_path, exist_ok=True)\\n\\n # Save intermediate checkpoint\\n policy.save_result(checkpoint_save_path)\\n\\n # Render environment if requested\\n if ENVS_PARAMS[ENV_NAME][\\\"eval_render\\\"]:\\n env.render()\\n\\n # Retrieve (scaled) action based on the current policy\\n # NOTE (rickstaa): The scaling operation is already performed inside the\\n # policy based on the `act_limits` you supplied.\\n a = policy.choose_action(s)\\n\\n # Perform action in env\\n s_, r, done, _ = env.step(a)\\n\\n # Increment global step count\\n if training_started:\\n global_step += 1\\n\\n # Stop episode if max_steps has been reached\\n if jj == ENVS_PARAMS[ENV_NAME][\\\"max_ep_steps\\\"] - 1:\\n done = True\\n terminal = 1.0 if done else 0.0\\n\\n # Store experience in replay buffer\\n pool.store(s, a, r, terminal, s_)\\n\\n # Optimize network weights and lagrance multipliers\\n if (\\n pool.memory_pointer > ALG_PARAMS[\\\"min_memory_size\\\"]\\n and global_step % ALG_PARAMS[\\\"steps_per_cycle\\\"] == 0\\n ):\\n training_started = True\\n\\n # Perform STG a set number of times (train per cycle)\\n for _ in range(ALG_PARAMS[\\\"train_per_cycle\\\"]):\\n batch = pool.sample(ALG_PARAMS[\\\"batch_size\\\"])\\n if policy.use_lyapunov:\\n (\\n labda,\\n alpha,\\n l_loss,\\n entropy,\\n a_loss,\\n alpha_loss,\\n labda_loss,\\n ) = policy.learn(lr_a_now, lr_l_now, lr_a, lr_c_now, batch)\\n else:\\n alpha, loss_q, entropy, a_loss, alpha_loss = policy.learn(\\n lr_a_now, lr_l_now, lr_a, lr_c_now, batch\\n )\\n\\n # Store current path results\\n if training_started:\\n if policy.use_lyapunov:\\n current_path[\\\"rewards\\\"].append(r)\\n current_path[\\\"lyapunov_error\\\"].append(l_loss)\\n current_path[\\\"alpha\\\"].append(alpha)\\n current_path[\\\"lambda\\\"].append(labda)\\n current_path[\\\"entropy\\\"].append(entropy)\\n current_path[\\\"a_loss\\\"].append(a_loss)\\n current_path[\\\"alpha_loss\\\"].append(alpha_loss)\\n current_path[\\\"lambda_loss\\\"].append(labda_loss)\\n else:\\n current_path[\\\"rewards\\\"].append(r)\\n current_path[\\\"critic_error\\\"].append(loss_q.numpy())\\n current_path[\\\"alpha\\\"].append(alpha.numpy())\\n current_path[\\\"entropy\\\"].append(entropy.numpy())\\n current_path[\\\"a_loss\\\"].append(\\n a_loss.numpy()\\n ) # Improve: Check if this is the fastest way\\n current_path[\\\"alpha_loss\\\"].append(alpha_loss)\\n\\n # Evalute the current policy performance and log the results\\n if (\\n training_started\\n and global_step % TRAIN_PARAMS[\\\"evaluation_frequency\\\"] == 0\\n and global_step > 0\\n ):\\n logger.logkv(\\\"total_timesteps\\\", global_step)\\n training_diagnostics = evaluate_training_rollouts(last_training_paths)\\n if training_diagnostics is not None:\\n if TRAIN_PARAMS[\\\"num_of_evaluation_paths\\\"] > 0:\\n eval_diagnostics = training_evaluation(test_env, policy)\\n [\\n logger.logkv(key, eval_diagnostics[key])\\n for key in eval_diagnostics.keys()\\n ]\\n training_diagnostics.pop(\\\"return\\\")\\n [\\n logger.logkv(key, training_diagnostics[key])\\n for key in training_diagnostics.keys()\\n ]\\n logger.logkv(\\\"lr_a\\\", lr_a_now)\\n if policy.use_lyapunov:\\n logger.logkv(\\\"lr_l\\\", lr_l_now)\\n else:\\n logger.logkv(\\\"lr_c\\\", lr_c_now)\\n string_to_print = [\\\"time_step:\\\", str(global_step), \\\"|\\\"]\\n if TRAIN_PARAMS[\\\"num_of_evaluation_paths\\\"] > 0:\\n [\\n string_to_print.extend(\\n [key, \\\":\\\", str(eval_diagnostics[key]), \\\"|\\\"]\\n )\\n for key in eval_diagnostics.keys()\\n ]\\n [\\n string_to_print.extend(\\n [key, \\\":\\\", str(round(training_diagnostics[key], 2)), \\\"|\\\"]\\n )\\n for key in training_diagnostics.keys()\\n ]\\n prefix = (\\n colorize(\\\"LAC|\\\", \\\"green\\\")\\n if ALG_PARAMS[\\\"use_lyapunov\\\"]\\n else colorize(\\\"SAC|\\\", \\\"yellow\\\")\\n )\\n print(\\n colorize(prefix, \\\"yellow\\\", bold=True) + \\\"\\\".join(string_to_print)\\n )\\n logger.dumpkvs()\\n\\n # Update state\\n s = s_\\n\\n # Check if episode is done (continue to next episode)\\n if done:\\n\\n # Store paths\\n if training_started:\\n last_training_paths.appendleft(current_path)\\n\\n # Decay learning rates\\n frac = 1.0 - (global_step - 1.0) / TRAIN_PARAMS[\\\"max_global_steps\\\"]\\n lr_a_now = lr_a * frac # learning rate for actor, lambda, alpha\\n lr_l_now = lr_l * frac # learning rate for Lyapunov critic\\n lr_c_now = lr_c * frac # learning rate for q critic\\n break # Continue to next episode\\n\\n # Increase episode counter\\n global_episodes += 1\",\n \"def train(self):\\n # setup model\\n self.createModel()\\n self.setGenerators()\\n self.buildCallbacks()\\n self.printParameters()\\n \\n # train model\\n _ = self.model.fit_generator(\\n generator = self.trainGen,\\n validation_data = self.validateGen,\\n steps_per_epoch = self.steps_per_epoch,\\n validation_steps = self.validation_steps,\\n epochs = self.epochs,\\n use_multiprocessing = True,\\n callbacks = self.callbacks)\\n # clear save paths to avoid overwriting accidentaly\\n self.saveName = None\",\n \"def train(self, args):\\n\\n ##################################\\n # Read the training data\\n ##################################\\n if not os.path.isdir(args.annotationPath):\\n print('annotation path does not exist: {}' \\\\\\n .format(args.annotationPath))\\n return -1\\n\\n data = self.readData(args.annotationPath)\\n\\n x = []\\n y = []\\n l = []\\n for subject, df in data.items():\\n lx = df[['gradient', 'rate']].values.tolist()\\n ly = np.array(df[['immersion']].values.tolist()).squeeze(-1)\\n x.extend(lx)\\n y.extend(ly.tolist())\\n l.append(len(lx))\\n\\n ############################\\n # Execute the training\\n ############################\\n\\n print('Training the detector...')\\n self._clf.fit(x, y, l)\\n\\n if not self.save():\\n print('Could not persist the trained model to disk (in file {})' \\\\\\n .format(self._modelFile))\\n\\n return 0\",\n \"def train(self, training_steps=10):\",\n \"def sentiment(dash_comment):\\n\\n label_list = [0,1]# Label categories\\n max_seq_length = 128# maximum length of (token) input sequences\\n train_batch_size = 32\\n\\n\\n # Get BERT layer and tokenizer:\\n # More details here: https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/4\\n\\n bert_layer = hub.KerasLayer('https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/2', trainable=True)\\n\\n vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()\\n do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()\\n tokenizer = tokenization.FullTokenizer(vocab_file,do_lower_case)\\n\\n def to_feature(text, label, label_list=label_list, max_seq_length=max_seq_length, tokenizer=tokenizer):\\n example = classifier_data_lib.InputExample(guid=None,\\n text_a = text.numpy(),\\n text_b = None,\\n label = label.numpy())\\n feature = classifier_data_lib.convert_single_example(0,example, label_list,max_seq_length,tokenizer)\\n\\n return (feature.input_ids, feature.input_mask, feature.segment_ids, feature.label_id)\\n\\n def to_feature_map(text, label):\\n input_ids, input_mask, segment_ids, label_id = tf.py_function(to_feature, inp=[text, label],\\n Tout = [tf.int32,tf.int32,tf.int32,tf.int32])\\n input_ids.set_shape([max_seq_length])\\n input_mask.set_shape([max_seq_length])\\n segment_ids.set_shape([max_seq_length])\\n label_id.set_shape([])\\n\\n x = {\\n 'input_word_ids': input_ids,\\n 'input_mask': input_mask,\\n 'input_type_ids': segment_ids\\n }\\n\\n return (x, label_id)\\n\\n def create_model():\\n input_word_ids = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\\n name=\\\"input_word_ids\\\")\\n input_mask = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\\n name=\\\"input_mask\\\")\\n input_type_ids = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\\n name=\\\"input_type_ids\\\")\\n pooled_output, sequence_output = bert_layer([input_word_ids, input_mask, input_type_ids])\\n\\n drop = tf.keras.layers.Dropout(0.4)(pooled_output)\\n output = tf.keras.layers.Dense(1, activation='sigmoid', name='output')(drop)\\n\\n model = tf.keras.Model(\\n inputs={\\n 'input_word_ids': input_word_ids,\\n 'input_mask': input_mask,\\n 'input_type_ids': input_type_ids\\n\\n },\\n outputs=output\\n )\\n return model\\n\\n def sentiment_classifier(list):\\n return max(set(list), key=list.count)\\n # right_test = pd.read_csv('/Users/steve/Google Drive/Dissertation/newtestconservative.csv', usecols=[1,2,3,4,5])\\n # left_test = pd.read_csv('/Users/steve/Google Drive/Dissertation/newtestliberal.csv', usecols=[1,2,3,4,5])\\n # test_df = pd.concat([right_test, left_test])\\n # test_df.columns = ['Comment', 'Date','Score','Subreddit','Label']\\n # test_df['Label'] = test_df['Label'].map({'Right-Wing':1, 'Left-Wing':0})\\n # test_df.Comment = test_df.Comment.astype(str)\\n\\n model = create_model()\\n model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=2e-5),\\n loss = tf.keras.losses.BinaryCrossentropy(),\\n metrics = [tf.keras.metrics.BinaryAccuracy()])\\n model.summary()\\n\\n print('Model loading')\\n model.load_weights('new_model_all_data_5epochs').expect_partial()\\n print('Model loaded')\\n sample_example = []\\n sample_example.append(dash_comment)\\n # # sample_example = ['Trump goes ahead with plans to build wall at the border of Mexico',\\n # # 'Brexit',\\n # # 'The EU is stealing our jobs',\\n # # 'Rep. Marjorie Taylor Greene has been suspended from tweeting for a week after she claimed on Twitter yesterday that vaccines are “failing.”',\\n # # 'All Rabbits should be placed on birth control. The cost of babies is ruining our democracy.',\\n # # 'Journalism is dead.',\\n # # 'fuck the tories',\\n # # 'I Love Joe Biden',\\n # # 'Boris Johnson is a responsible for brexit'\\n # ]\\n\\n test_data = tf.data.Dataset.from_tensor_slices((sample_example, [0]*len(sample_example)))\\n test_data = (test_data.map(to_feature_map).batch(1))\\n print('predicting')\\n preds=model.predict(test_data, verbose=1)\\n threshold = 0.5\\n result = [1 if pred >= threshold else 0 for pred in preds]\\n results = []\\n for i in preds:\\n if i <=0.25:\\n results.append('Strongly Left-wing')\\n elif i >= 0.25 and i < 0.40:\\n results.append('Somewhat Left-wing')\\n elif i >= 0.40 and i < 0.50:\\n results. append('Slightly Left-wing')\\n elif i == 0.5:\\n results.append('Neutral')\\n elif i >= 0.5 and i < 0.60:\\n results.append('Slightly Right-wing')\\n elif i >= 0.60 and i < 0.75:\\n results. append('Somewhat Right-wing')\\n elif i >= 0.75:\\n results.append('Strongly Right-wing')\\n\\n return \\\"{scr}\\\".format(scr=sentiment_classifier(results))\\n # y_true = [1,1,1,0,1,1,0,0,0]\\n # report = classification_report(y_true, result)\\n # print(report)\\n # print(results)\",\n \"def train(self, batch):\\n pass\",\n \"def main_modeling_pipeline():\\n\\n\\n data_df = pd.read_csv('gs://aiplatformfilipegracio2020/head_train_data.csv')\\n data_df = data_df[[LABEL, 'price', 'days_on_site']]\\n\\n class_weights = calculate_class_weights(data_df[LABEL])\\n print('class weights', class_weights)\\n logging.info('Data loaded and processed')\\n train_ds, val_ds, test_ds = make_tf_datasets(data_df, LABEL)\\n logging.info('Tensorflow datasets created')\\n\\n with strategy.scope():\\n logging.info('Inside strategy')\\n simple_feature_layer = make_simple_feature_layer(data_df)\\n logging.info('Going to make model')\\n simple_model = make_simple_model(simple_feature_layer)\\n\\n logging.info('Going fit model')\\n simple_model_results, simple_model = model_fit_and_evaluate(model=simple_model,\\n train_ds=train_ds,\\n val_ds=val_ds,\\n test_ds=test_ds,\\n class_weights=class_weights,\\n epochs=TRAINING_EPOCHS,\\n job_name='simple_model')\\n\\n simple_model.save('gs://aiplatformfilipegracio2020/')\",\n \"def initiate(self):\\n # if self.opt.checkpoint_encoder:\\n # self.load(self.opt.checkpoint_encoder, self.opt.checkpoint_decoder)\\n # else:\\n # start fresh.\\n self.model = Transformer(\\n self.opt.src_vocab_size,\\n self.opt.tgt_vocab_size,\\n self.opt.max_token_seq_len,\\n tgt_emb_prj_weight_sharing=self.opt.proj_share_weight,\\n emb_src_tgt_weight_sharing=self.opt.embs_share_weight,\\n d_k=self.opt.d_k,\\n d_v=self.opt.d_v,\\n d_model=self.opt.d_model,\\n d_word_vec=self.opt.d_word_vec,\\n d_inner=self.opt.d_inner_hid,\\n n_layers=self.opt.layers,\\n n_head=self.opt.n_head,\\n dropout=self.opt.dropout).to(self.device)\\n \\n for p in self.model.parameters():\\n if p.dim() > 1:\\n nn.init.xavier_uniform_(p)\",\n \"def train(self):\\n self.ae_train(self.net0, self.ae0_optimizer, self.train0_loader, self.val_loader, name='Net0')\\n self.ae_train(self.net1, self.ae1_optimizer, self.train1_loader, self.val_loader, name='Net1')\\n self.ae_train(self.net2, self.ae2_optimizer, self.train2_loader, self.val_loader, name='Net2')\\n\\n self.classifier_train(self.net0, self.optimizer0, self.train0_loader, self.val_loader, name='Net0')\\n self.classifier_train(self.net1, self.optimizer1, self.train1_loader, self.val_loader, name='Net1')\\n self.classifier_train(self.net2, self.optimizer2, self.train2_loader, self.val_loader, name='Net2')\",\n \"def train(self, session, train_examples, dev_examples, train_dir):\\n\\n # some free code to print out number of parameters in your model\\n # it's always good to check!\\n # you will also want to save your model parameters in train_dir\\n # so that you can use your trained model to make predictions, or\\n # even continue training\\n\\n tic = time.time()\\n params = tf.trainable_variables()\\n num_params = sum(map(lambda t: np.prod(tf.shape(t.value()).eval()), params))\\n toc = time.time()\\n logging.info(\\\"Number of params: %d (retreival took %f secs)\\\" % (num_params, toc - tic))\\n\\n if self.summary_flag:\\n self.train_writer = tf.summary.FileWriter(self.summaries_dir + '/train', session.graph)\\n\\n logging.info(\\\"Train Loss File: {}\\\".format(self.train_loss_log))\\n logging.info(\\\"Dev Loss File: {}\\\".format(self.dev_loss_log))\\n best_score = 100000\\n train_log = open(self.train_loss_log, \\\"w\\\")\\n dev_log = open(self.dev_loss_log, \\\"w\\\")\\n for epoch in range(self.n_epoch):\\n print(\\\"Epoch {:} out of {:}\\\".format(epoch + 1, self.n_epoch))\\n dev_score = self.run_epoch(session, train_examples, dev_examples, epoch, train_log)\\n dev_log.write(\\\"{},{}\\\\n\\\".format(epoch + 1, dev_score))\\n logging.info(\\\"Average Dev Cost: {}\\\".format(dev_score))\\n logging.info(\\\"train F1 & EM\\\")\\n f1, em = self.evaluate_answer(session, train_examples, self.rev_vocab, log = True)\\n logging.info(\\\"Dev F1 & EM\\\")\\n f1, em = self.evaluate_answer(session, dev_examples, self.rev_vocab, log = True)\\n if dev_score < best_score:\\n best_score = dev_score\\n print(\\\"New best dev score! Saving model in {}\\\".format(train_dir + \\\"/\\\" + self.model_name))\\n self.saver.save(session, train_dir + \\\"/\\\" + self.model_name)\\n\\n return best_score\",\n \"def train():\\n \\n ## check for request data\\n if not request.json:\\n print(\\\"ERROR: API (train): did not receive request data\\\")\\n return jsonify(False)\\n\\n ## set the test flag\\n test = False\\n if 'mode' in request.json and request.json['mode'] == 'test':\\n test = True\\n\\n print(\\\"... training model\\\")\\n model = model_train(test=test)\\n print(\\\"... training complete\\\")\\n\\n return(jsonify(True))\",\n \"def train(self):\\n backend = self.config.backend.build(self.config, self.tmp_dir)\\n backend.train(source_bundle_uri=self.config.source_bundle_uri)\",\n \"def train(articles, force_create=False):\\n global _trained\\n # Setup\\n bag_of_words.train(articles, force_create)\\n term_frequency.train(articles, force_create)\\n _get_idfs(articles)\\n _trained = True\\n for article in articles:\\n get_vector(article, force_create, True)\",\n \"def main():\\n # Read data for train set\\n print('loading training data')\\n train = read_datafile('../data/tsd_train.csv')\\n\\n # Read trial data for validation set\\n validation = read_datafile('../data/tsd_trial.csv')\\n\\n # Read data for test set\\n print('loading test data')\\n test = read_datafile('../data/tsd_test.csv')\\n\\n # Convert training data to Spacy Entities\\n nlp = spacy.load(\\\"en_core_web_sm\\\")\\n print('preparing training data')\\n training_data = []\\n for n, (spans, text) in enumerate(train):\\n doc = nlp(text)\\n ents = spans_to_ents(doc, set(spans), 'TOXIC')\\n training_data.append((doc.text, {'entities': ents}))\\n\\n toxic_tagging = spacy.blank('en')\\n toxic_tagging.vocab.strings.add('TOXIC')\\n ner = nlp.create_pipe(\\\"ner\\\")\\n toxic_tagging.add_pipe(ner, last=True)\\n ner.add_label('TOXIC')\\n\\n pipe_exceptions = [\\\"ner\\\", \\\"trf_wordpiecer\\\", \\\"trf_tok2vec\\\"]\\n unaffected_pipes = [\\n pipe for pipe in toxic_tagging.pipe_names\\n if pipe not in pipe_exceptions]\\n\\n\\n print('Training!')\\n with toxic_tagging.disable_pipes(*unaffected_pipes):\\n \\n toxic_tagging.begin_training()\\n for iteration in range(30):\\n random.shuffle(training_data)\\n losses = {}\\n batches = spacy.util.minibatch(\\n training_data, size=spacy.util.compounding(\\n 4.0, 32.0, 1.001))\\n for batch in batches:\\n texts, annotations = zip(*batch)\\n toxic_tagging.update(texts, annotations, drop=0.5, losses=losses)\\n print(\\\"Losses\\\", losses)\\n\\n\\n # Define helper function for evaluating datasets\\n def evaluate(dateset):\\n precision_recall_f1_scores = []\\n for spans, text in dateset:\\n pred_spans = []\\n doc = toxic_tagging(text)\\n for ent in doc.ents:\\n pred_spans.extend(range(ent.start_char, ent.start_char + len(ent.text)))\\n \\n # score = semeval2021.f1(pred_spans, spans)\\n precision_recall_f1_scores.append(per_post_precision_recall_f1(pred_spans, spans))\\n\\n # compute average precision, recall and f1 score of all posts\\n return np.array(precision_recall_f1_scores).mean(axis=0)\\n\\n # Evaluate on dev and test sets\\n print('Evaluation:')\\n eval_precision, eval_recall, eval_f1 = evaluate(validation)\\n test_precision, test_recall, test_f1 = evaluate(test)\\n \\n print(f'Dev set: Precision = {eval_precision}, Recall = {eval_recall}, F1 = {eval_f1}')\\n print(f'Test set: Precision = {test_precision}, Recall = {test_recall}, F1 = {test_f1}')\",\n \"def train_model(args: argparse.Namespace, hp: HParams, extension_architecture: str, timestamp: str,\\n logger: logging.Logger) -> None:\\n # 1. Check if we have to train a single tier or a complete model (with several tiers)\\n if args.tier is not None:\\n # 1.1 Argument tier was defined. Only that tier will be trained.\\n logging.info(f\\\"Training single tier of the model: Tier {args.tier}\\\")\\n\\n # 2. Setup tensorboard logging\\n # 2.1 Create tensorboard logs directory (tensorboard requires a different folder for each\\n # run of the model, in this case every run to train a tier) so we add the extension of the\\n # network's architecture of this run and the timestamp to identify it completely\\n tensorboard_dir = f\\\"{hp.logging.dir_log_tensorboard}{extension_architecture}_\\\" \\\\\\n f\\\"{timestamp}_tier{args.tier}\\\"\\n Path(tensorboard_dir).mkdir(parents=True, exist_ok=True)\\n # 2.2 Create tensorboard writer\\n tensorboardwriter = TensorboardWriter(hp, tensorboard_dir)\\n\\n # 3. Start training of the tier\\n train_tier(args, hp, args.tier, extension_architecture, timestamp, tensorboardwriter,\\n logger)\\n\\n tensorboardwriter.close()\\n\\n else:\\n # 1.2 Argument tier was not defined. Train all tiers of the model.\\n logging.info(\\\"Training all tiers of the model\\\")\\n\\n for tier in range(1, hp.network.n_tiers + 1):\\n # 2. Setup tensorboard logging (one for every tier)\\n # 2.1 Create tensorboard logs directory (tensorboard requires a different folder for\\n # each run of the model, in this case every run to train a tier) so we add the extension\\n # of the network's architecture of this run and the timestamp to identify it completely\\n tensorboard_dir = hp.logging.dir_log_tensorboard + extension_architecture \\\\\\n + f\\\"_{timestamp}_tier{tier}\\\"\\n Path(tensorboard_dir).mkdir(parents=True, exist_ok=True)\\n # 2.2 Create tensorboard writer\\n tensorboardwriter = TensorboardWriter(hp, tensorboard_dir)\\n\\n # 3. Start training of the tier\\n train_tier(args, hp, tier, extension_architecture, timestamp, tensorboardwriter, logger)\\n\\n tensorboardwriter.close()\\n del tensorboardwriter\",\n \"def train(self, training_data: TrainingData, config: RasaNLUModelConfig, **kwargs: Any) -> None:\\n pass\",\n \"def inc_train(self, conf):\\n conf['angel.worker.matrix.transfer.request.timeout.ms'] = 60000\\n conf[AngelConf.ANGEL_TASK_USER_TASKCLASS] = 'com.tencent.angel.ml.regression.linear.LinearRegTrainTask'\\n\\n # Create an angel job client\\n client = AngelClientFactory.get(conf)\\n\\n # Submit this application\\n client.startPSServer()\\n\\n # Create a model\\n model = conf._jvm.com.tencent.angel.ml.regression.linear.LinearRegModel(conf._jconf)\\n\\n # Load model meta to client\\n client.loadModel(model)\\n\\n # Run user task\\n client.runTask('com.tencent.angel.ml.regression.linear.LinearRegTrainTask')\\n\\n # Wait for completion,\\n # User task is set in AngelConf.ANGEL_TASK_USER_TASKCLASS\\n client.waitForCompletion()\\n\\n # Save the incremental trained model to HDFS\\n client.saveModel(model)\\n\\n # Stop\\n client.stop()\",\n \"def set_train(self):\\n self.model.train()\",\n \"def train_model(\\n fname: Path,\\n save_name: Path,\\n batch_size: int = 32,\\n warmup_steps: int = 100,\\n steps: int = 1000,\\n num_heads: int = 2,\\n model_dim: int = 128,\\n key_dim: int = 128,\\n value_dim: int = 128,\\n dropout: float = 0.1,\\n num_mask: int = 9,\\n):\\n seqs = read_fasta(fname)\\n\\n X = seqs_to_integer(seqs)\\n\\n X = torch.from_numpy(X).type(torch.LongTensor)\\n\\n X_train, X_test = random_split(X)\\n\\n train_params = {\\n \\\"batch_size\\\": batch_size,\\n \\\"lr\\\": 0.0005,\\n \\\"weight_decay\\\": 0.0,\\n \\\"warmup_steps\\\": warmup_steps,\\n \\\"steps\\\": steps,\\n }\\n model_params[\\\"n_head\\\"] = num_heads\\n model_params[\\\"d_model\\\"] = model_dim\\n model_params[\\\"d_k\\\"] = key_dim\\n model_params[\\\"d_v\\\"] = value_dim\\n model_params[\\\"dropout\\\"] = dropout\\n model_params[\\\"num_mask\\\"] = num_mask\\n\\n model = BERT(**model_params)\\n\\n optimizer = Adam(\\n model.parameters(),\\n lr=train_params[\\\"lr\\\"],\\n weight_decay=train_params[\\\"weight_decay\\\"],\\n )\\n\\n scheduler = WarmupAnnealLR(optimizer, warmup_steps=train_params[\\\"warmup_steps\\\"])\\n\\n train(\\n model,\\n X_train,\\n X_test,\\n save_name,\\n batch_size=train_params[\\\"batch_size\\\"],\\n optimizer=optimizer,\\n scheduler=scheduler,\\n steps=train_params[\\\"steps\\\"],\\n pbar_increment=10,\\n )\",\n \"def model_fn(features, labels, mode, params): # pylint: disable=unused-argument\\n\\n # tf.logging.info(\\\"*** Features ***\\\")\\n # for name in sorted(features.keys()):\\n # tf.logging.info(\\\" name = %s, shape = %s\\\" % (name, features[name].shape))\\n\\n input_ids = features[\\\"input_ids\\\"]\\n input_mask = features[\\\"input_mask\\\"]\\n segment_ids = features[\\\"segment_ids\\\"]\\n label_ids = features[\\\"label_ids\\\"]\\n is_real_example = None\\n if \\\"is_real_example\\\" in features:\\n is_real_example = tf.cast(features[\\\"is_real_example\\\"], dtype=tf.float32)\\n else:\\n is_real_example = tf.ones(tf.shape(label_ids), dtype=tf.float32)\\n\\n is_training = mode == tf.estimator.ModeKeys.TRAIN\\n\\n model = modeling.BertModel(\\n config=bert_config,\\n is_training=is_training,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n token_type_ids=segment_ids,\\n use_one_hot_embeddings=use_one_hot_embeddings,\\n )\\n\\n tvars = tf.trainable_variables()\\n initialized_variable_names = {}\\n scaffold_fn = None\\n if init_checkpoint:\\n (\\n assignment_map,\\n initialized_variable_names,\\n ) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\\n if use_tpu:\\n\\n def tpu_scaffold():\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n return tf.train.Scaffold()\\n\\n scaffold_fn = tpu_scaffold\\n else:\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n\\n tf.logging.info(\\\"**** Trainable Variables ****\\\")\\n for var in tvars:\\n init_string = \\\"\\\"\\n if var.name in initialized_variable_names:\\n init_string = \\\", *INIT_FROM_CKPT*\\\"\\n\\n output_spec = None\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n\\n train_op = optimization.create_optimizer(\\n total_loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu\\n )\\n\\n output_spec = tf.estimator.EstimatorSpec(\\n mode=mode, loss=total_loss, train_op=train_op, scaffold=scaffold_fn\\n )\\n elif mode == tf.estimator.ModeKeys.EVAL:\\n\\n def metric_fn(per_example_loss, label_ids, probabilities, is_real_example):\\n\\n logits_split = tf.split(probabilities, num_labels, axis=-1)\\n label_ids_split = tf.split(label_ids, num_labels, axis=-1)\\n # metrics change to auc of every class\\n eval_dict = {}\\n for j, logits in enumerate(logits_split):\\n label_id_ = tf.cast(label_ids_split[j], dtype=tf.int32)\\n current_auc, update_op_auc = tf.metrics.auc(label_id_, logits)\\n eval_dict[str(j)] = (current_auc, update_op_auc)\\n eval_dict[\\\"eval_loss\\\"] = tf.metrics.mean(values=per_example_loss)\\n return eval_dict\\n\\n\\n eval_metrics = metric_fn(\\n per_example_loss, label_ids, probabilities, is_real_example\\n )\\n output_spec = tf.estimator.EstimatorSpec(\\n mode=mode,\\n loss=total_loss,\\n eval_metric_ops=eval_metrics,\\n scaffold=scaffold_fn,\\n )\\n else:\\n out = {\\n \\\"input_ids\\\": input_ids,\\n \\\"label_ids\\\": label_ids,\\n }\\n all_layers = model.get_all_encoder_layers()\\n for (i, layer_index) in enumerate(layer_indexes):\\n out[\\\"layer_output_%d\\\" % i] = all_layers[layer_index]\\n\\n output_spec = tf.estimator.EstimatorSpec(\\n mode=mode, predictions=out, scaffold=scaffold_fn\\n )\\n return output_spec\",\n \"def train(self):\\n\\n agent_step = self._num_actions_taken\\n\\n if agent_step >= self._train_after:\\n if (agent_step % self._train_interval) == 0:\\n pre_states, actions, post_states, rewards, terminals = self._memory.minibatch(self._minibatch_size)\\n\\n self._trainer.train_minibatch(\\n self._trainer.loss_function.argument_map(\\n pre_states=pre_states,\\n actions=Value.one_hot(actions.reshape(-1, 1).tolist(), self.nb_actions),\\n post_states=post_states,\\n rewards=rewards,\\n terminals=terminals\\n )\\n )\\n\\n # Update the Target Network if needed\\n if (agent_step % self._target_update_interval) == 0:\\n self._target_net = self._action_value_net.clone(CloneMethod.freeze)\\n filename = \\\"models\\\\model%d\\\" % agent_step\\n self._trainer.save_checkpoint(filename)\",\n \"def train(self) -> Any:\\n pass\",\n \"def train(self, training_data):\\n pass\",\n \"def model_fn_builder(bert_config, init_checkpoint, learning_rate,\\n num_train_steps, num_warmup_steps, use_one_hot_embeddings,\\n input_seq_length, target_seq_length, target_start_ids, target_end_ids, batch_size,mode_type=\\\"lstm\\\"):\\n mode_type=mode_type.lower()\\n def model_fn(features, labels, mode, params):\\n tf.logging.info(\\\"*** Features ***\\\")\\n for name in sorted(features.keys()):\\n tf.logging.info(\\\" name = %s, shape = %s\\\" % (name, features[name].shape))\\n sentiment_labels = features[\\\"sentiment_labels\\\"]\\n input_mask = features[\\\"input_mask\\\"]\\n input_token_ids = features[\\\"input_token_ids\\\"]\\n target_token_ids = features[\\\"target_token_ids\\\"]\\n target_mask = features[\\\"target_mask\\\"]\\n segment_ids = features[\\\"segment_ids\\\"]\\n tf.logging.info(input_token_ids.shape)\\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\\n if mode_type==\\\"lstm_attention\\\":\\n #lstm-attention\\n (loss, logts, sample_id,scores,output_token_ids,outputs_mask) = create_model_lstm_attention(bert_config, is_training, input_token_ids, sentiment_labels, input_mask,\\n segment_ids,\\n target_token_ids, target_mask, target_start_ids, target_end_ids\\n , input_seq_length,target_seq_length, mode, batch_size, use_one_hot_embeddings)\\n elif mode_type==\\\"seq2seq_lstm_attention\\\":\\n (loss, logts, sample_id,scores,output_token_ids,outputs_mask) = create_model_seq2seq_lstm_attention(bert_config, is_training, input_token_ids, sentiment_labels, input_mask,\\n segment_ids,\\n target_token_ids, target_mask, target_start_ids, target_end_ids\\n , input_seq_length,target_seq_length, mode, batch_size, use_one_hot_embeddings)\\n\\n\\n elif mode_type==\\\"lstm\\\":\\n #lstm-nonattention\\n (loss, logts, sample_id,scores,output_token_ids,outputs_mask) = create_model(bert_config, is_training, input_token_ids, sentiment_labels, input_mask,\\n segment_ids,\\n target_token_ids, target_mask, target_start_ids, target_end_ids\\n , target_seq_length, mode, batch_size, use_one_hot_embeddings)\\n elif mode_type==\\\"seq2seq_lstm_attention_with_condition\\\":\\n (loss, logts, sample_id,scores,output_token_ids,outputs_mask) = create_model_seq2seq_lstm_attention_with_condition(bert_config, is_training, input_token_ids, sentiment_labels, input_mask,\\n segment_ids,\\n target_token_ids, target_mask, target_start_ids, target_end_ids\\n , input_seq_length,target_seq_length, mode, batch_size, use_one_hot_embeddings)\\n\\n else:\\n raise TypeError(\\\"None type with {} in ['lstm','lstm_attention']\\\".format(mode_type))\\n\\n tvars = tf.trainable_variables()\\n initialized_variable_names = {}\\n if init_checkpoint:\\n (assignment_map, initialized_variable_names\\n ) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n\\n tf.logging.info(\\\"**** Trainable Variables ****\\\")\\n for var in tvars:\\n init_string = \\\"\\\"\\n if var.name in initialized_variable_names:\\n init_string = \\\", *INIT_FROM_CKPT*\\\"\\n tf.logging.info(\\\" name = %s, shape = %s%s\\\", var.name, var.shape,\\n init_string)\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n\\n train_op = optimization.create_optimizer(\\n loss, learning_rate, num_train_steps, num_warmup_steps\\n )\\n accuracy = tf.metrics.accuracy(output_token_ids, sample_id, weights=outputs_mask)\\n tf.summary.scalar(\\\"accuracy_train\\\", accuracy[1])\\n output_spec = tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)\\n\\n elif mode == tf.estimator.ModeKeys.EVAL:\\n\\n accuracy = tf.metrics.accuracy(output_token_ids,sample_id , weights=outputs_mask)\\n eval_metrics = {\\\"accuracy\\\": accuracy}\\n tf.summary.scalar(\\\"accuracy_eval\\\", accuracy[1])\\n output_spec = tf.estimator.EstimatorSpec(mode=mode, loss=loss\\n , eval_metric_ops=eval_metrics)\\n\\n else:\\n predictions={\\\"sample_id\\\": sample_id,\\\"inputs\\\":input_token_ids}\\n if scores is not None:\\n predictions[\\\"scores\\\"]=scores\\n\\n output_spec = tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)\\n\\n return output_spec\\n\\n return model_fn\",\n \"def train(self, X, y):\\n self.model.fit(X, y)\",\n \"def train_models(self):\\n\\n #keep track on the number of iterations (needed to scale lambda)\\n nr_iteration = 0\\n \\n for epoch in range(self.epochs):\\n start = time.time()\\n print()\\n print(epoch + 1)\\n print()\\n for step, batch in enumerate(self.training_data):\\n X_batch = normalize_images(tf.cast(batch[0], 'float32'))\\n Y_batch = batch[1]\\n Z_batch = self.ae_model.encode(X_batch)\\n \\n self.train_step_disc(Z_batch, Y_batch)\\n # Call only one tf.function when tracing.\\n #ADD LAMBDA SCHEDULE ACCORDING TO OUR EXPERIMENTS AND EPOCH LENGTH\\n self.scale_lambda(self.lambda_e, nr_iteration)\\n self.train_step_ae(X_batch, Y_batch, Z_batch)\\n\\n nr_iteration += 1\\n end = time.time()\\n print(\\\"Epoch \\\" + str(epoch + 1) + \\\" takes \\\" + str(end - start))\",\n \"def train(model: ContinualModel, dataset: ContinualDataset,\\n args: Namespace) -> None:\\n model.net.to(model.device)\\n results, results_mask_classes = [], []\\n \\n model_stash = create_stash(model, args, dataset)\\n \\n if args.csv_log:\\n csv_logger = CsvLogger(dataset.SETTING, dataset.NAME, model.NAME)\\n if args.tensorboard:\\n tb_logger = TensorboardLogger(args, dataset.SETTING, model_stash)\\n model_stash['tensorboard_name'] = tb_logger.get_name()\\n \\n dataset_copy = get_dataset(args)\\n for t in range(dataset.N_TASKS):\\n model.net.train()\\n _, _ = dataset_copy.get_data_loaders()\\n if model.NAME != 'icarl' and model.NAME != 'pnn':\\n random_results_class, random_results_task = evaluate(model, dataset_copy)\\n \\n print(file=sys.stderr)\\n for t in range(dataset.N_TASKS):\\n model.net.train()\\n train_loader, test_loader = dataset.get_data_loaders()\\n if hasattr(model, 'begin_task'):\\n model.begin_task(dataset)\\n if t:\\n accs = evaluate(model, dataset, last=True)\\n results[t - 1] = results[t - 1] + accs[0]\\n if dataset.SETTING == 'class-il':\\n results_mask_classes[t - 1] = results_mask_classes[t - 1] + accs[1]\\n for epoch in range(args.n_epochs):\\n for i, data in enumerate(train_loader):\\n if hasattr(dataset.train_loader.dataset, 'logits'):\\n inputs, labels, not_aug_inputs, logits = data\\n inputs = inputs.to(model.device)\\n labels = labels.to(model.device)\\n not_aug_inputs = not_aug_inputs.to(model.device)\\n logits = logits.to(model.device)\\n loss = model.observe(inputs, labels, not_aug_inputs, logits)\\n else:\\n inputs, labels, not_aug_inputs = data\\n inputs, labels = inputs.to(model.device), labels.to(\\n model.device)\\n not_aug_inputs = not_aug_inputs.to(model.device)\\n loss = model.observe(inputs, labels, not_aug_inputs)\\n \\n progress_bar(i, len(train_loader), epoch, t, loss)\\n \\n if args.tensorboard:\\n tb_logger.log_loss(loss, args, epoch, t, i)\\n \\n model_stash['batch_idx'] = i + 1\\n model_stash['epoch_idx'] = epoch + 1\\n model_stash['batch_idx'] = 0\\n model_stash['task_idx'] = t + 1\\n model_stash['epoch_idx'] = 0\\n \\n if hasattr(model, 'end_task'):\\n model.end_task(dataset)\\n \\n accs = evaluate(model, dataset)\\n results.append(accs[0])\\n results_mask_classes.append(accs[1])\\n \\n mean_acc = np.mean(accs, axis=1)\\n print_mean_accuracy(mean_acc, t + 1, dataset.SETTING)\\n \\n model_stash['mean_accs'].append(mean_acc)\\n if args.csv_log:\\n csv_logger.log(mean_acc)\\n if args.tensorboard:\\n tb_logger.log_accuracy(np.array(accs), mean_acc, args, t)\\n \\n if args.csv_log:\\n csv_logger.add_bwt(results, results_mask_classes)\\n csv_logger.add_forgetting(results, results_mask_classes)\\n if model.NAME != 'icarl' and model.NAME != 'pnn':\\n csv_logger.add_fwt(results, random_results_class,\\n results_mask_classes, random_results_task)\\n \\n if args.tensorboard:\\n tb_logger.close()\\n if args.csv_log:\\n csv_logger.write(vars(args))\",\n \"def model_fn_builder(albert_config,num_labels,init_checkpoint,learning_rate,\\n num_train_steps,num_warmup_steps,\\n use_one_hot_embeddings,optimizer='adamw'):\\n\\n def model_fn(features,labels,mode,params):\\n \\\"\\\"\\\"The `model_fn` for TPUEstimator.\\\"\\\"\\\"\\n tf.logging.info('*** Features ***')\\n for name in sorted(features.keys()):\\n tf.logging.info(\\\" name = %s ,shape = %s\\\" % (name,features[name].shape))\\n\\n input_ids = features['input_ids']\\n input_mask = features['input_mask']\\n segment_ids = features['segment_ids']\\n label_ids = features['label_ids']\\n if 'is_real_example' in features:\\n is_real_example = tf.cast(features['is_real_example'],dtype=tf.float32)\\n else:\\n is_real_example = tf.ones(tf.shape(label_ids),dtype=tf.float32)\\n\\n is_training = (mode == tf_estimator.estimator.ModeKeys.TRAIN)\\n\\n (total_loss,per_example_loss,probabilities,predictions) = \\\\\\n create_model(albert_config,is_training,input_ids,input_mask,\\n segment_ids,label_ids,num_labels,\\n use_one_hot_embeddings)\\n\\n tvars = tf.trainable_variables()\\n initialized_variable_names = {}\\n if init_checkpoint:\\n (assignment_map,initialized_variable_names) = modeling.get_assignment_map_from_checkpoint(tvars,init_checkpoint)\\n tf.train.init_from_checkpoint(init_checkpoint,assignment_map)\\n\\n tf.logging.info(\\\"**** Trainable Variables ****\\\")\\n for var in tvars:\\n init_string = \\\"\\\"\\n if var.name in initialized_variable_names:\\n init_string = \\\", *INIT_FROM_CKPT*\\\"\\n tf.logging.info(\\\" name = %s, shape = %s%s\\\", var.name, var.shape,\\n init_string)\\n\\n output_spec = None\\n if mode == tf_estimator.estimator.ModeKeys.TRAIN:\\n train_op = optimization.create_optimizer(total_loss,\\n learning_rate,\\n num_train_steps,\\n num_warmup_steps,use_tpu=False)\\n output_spec = tf_estimator.estimator.EstimatorSpec(\\n mode=mode,\\n loss=total_loss,\\n train_op=train_op,\\n )\\n elif mode == tf_estimator.estimator.ModeKeys.EVAL:\\n def metric_fn(per_example_loss,label_ids,logits,is_real_example):\\n accuracy = tf.metrics.accuracy(\\n labels=label_ids,predictions=predictions,\\n weights=is_real_example\\n )\\n loss = tf.metrics.mean(\\n values=per_example_loss,weights=is_real_example\\n )\\n return {\\n 'eval_accuracy':accuracy,\\n 'eval_loss':loss,\\n }\\n\\n eval_metrics = metric_fn(per_example_loss,label_ids,predictions,is_real_example)\\n output_spec = tf_estimator.estimator.EstimatorSpec(\\n mode=mode,\\n loss=total_loss,\\n eval_metric_ops=eval_metrics\\n )\\n else:\\n output_spec = tf_estimator.estimator.EstimatorSpec(\\n mode=mode,\\n predictions={\\n 'probabilities':probabilities,\\n 'predictions':predictions,\\n },\\n )\\n\\n return output_spec\\n\\n return model_fn\",\n \"def _train_model(self, df_train):\\n # type: (List[List[Tuple[Text, Text, Text, Text]]]) -> None\\n import sklearn_crfsuite\\n\\n X_train = [self._sentence_to_features(sent) for sent in df_train]\\n y_train = [self._sentence_to_labels(sent) for sent in df_train]\\n\\n from itertools import chain\\n\\n import nltk\\n import sklearn\\n import scipy.stats\\n from sklearn.metrics import make_scorer\\n from sklearn.model_selection import cross_val_score\\n from sklearn.model_selection import RandomizedSearchCV\\n\\n import sklearn_crfsuite\\n from sklearn_crfsuite import scorers\\n from sklearn_crfsuite import metrics\\n\\n X_train = [self._sentence_to_features(sent) for sent in df_train]\\n y_train = [self._sentence_to_labels(sent) for sent in df_train]\\n\\n if self.component_config[\\\"grid_search\\\"]:\\n self.ent_tagger = sklearn_crfsuite.CRF(\\n algorithm='lbfgs',\\n # stop earlier\\n max_iterations=self.component_config[\\\"max_iterations\\\"],\\n # include transitions that are possible, but not observed\\n all_possible_transitions=True\\n )\\n self.ent_tagger.fit(X_train, y_train)\\n\\n params_space = {\\n 'c1': scipy.stats.expon(scale=0.5),\\n 'c2': scipy.stats.expon(scale=0.5),\\n }\\n labels = self.ent_tagger.classes_\\n\\n # use the same metric for evaluation\\n f1_scorer = make_scorer(metrics.flat_f1_score,\\n average='weighted', labels=labels)\\n\\n # search\\n rs = RandomizedSearchCV(self.ent_tagger, params_space,\\n cv=10,\\n verbose=1,\\n n_jobs=-1,\\n n_iter=100,\\n scoring=f1_scorer)\\n rs.fit(X_train, y_train)\\n print('best params:', rs.best_params_)\\n print('best CV score:', rs.best_score_)\\n print('model size: {:0.2f}M'.format(rs.best_estimator_.size_ / 1000000))\\n try:\\n import json\\n with open(\\\"tunning_score.json\\\", \\\"w\\\") as f:\\n json.dump(rs.best_params_, f, sort_keys=True, indent=4)\\n except Exception:\\n pass\\n self.ent_tagger = sklearn_crfsuite.CRF(\\n algorithm='lbfgs',\\n c1=rs.best_params_[\\\"c1\\\"],\\n c2=rs.best_params_[\\\"c2\\\"],\\n # stop earlier\\n max_iterations=self.component_config[\\\"max_iterations\\\"],\\n # include transitions that are possible, but not observed\\n all_possible_transitions=True\\n )\\n else:\\n print(\\\"L1_c\\\", self.component_config[\\\"L1_c\\\"])\\n print(\\\"L2_c\\\", self.component_config[\\\"L2_c\\\"])\\n self.ent_tagger = sklearn_crfsuite.CRF(\\n algorithm='lbfgs',\\n # coefficient for L1 penalty\\n c1=self.component_config[\\\"L1_c\\\"],\\n # coefficient for L2 penalty\\n c2=self.component_config[\\\"L2_c\\\"],\\n # stop earlier\\n max_iterations=self.component_config[\\\"max_iterations\\\"],\\n # include transitions that are possible, but not observed\\n all_possible_transitions=True\\n )\\n\\n self.ent_tagger.fit(X_train, y_train)\",\n \"def train(train_x_df, train_y_df):\\n x = list(train_x_df.columns.values)\\n model = build_model(len(x))\\n\\n os.makedirs(\\\"./saved_models\\\", exist_ok=True)\\n\\n cp_callback = keras.callbacks.ModelCheckpoint(\\n checkpoint_path, save_weights_only=True, save_best_only=True, verbose=1\\n )\\n\\n # first 80 percent for training\\n train_x = train_x_df[1:246005]\\n train_y = train_y_df[1:246005]\\n\\n # other 20 percent for evaluating\\n eval_x = train_x_df[246006 : len(train_x_df) - 1]\\n eval_y = train_y_df[246006 : len(train_y_df) - 1]\\n\\n # train model\\n model.fit(\\n train_x,\\n train_y,\\n epochs=epochs,\\n validation_split=0.2,\\n verbose=0,\\n batch_size=batch_size,\\n callbacks=[cp_callback],\\n )\\n\\n print(\\\"done training\\\")\\n\\n # export the tensorflow model to a onnx model file\\n # for loading in tfe and secure enclave\\n export_to_onnx(\\n x,\\n model,\\n \\\"./house_credit_default.onnx\\\",\\n )\\n\\n # evaluate the model using AUC, the metric used in the kaggle competition\\n loss = model.evaluate(eval_x, eval_y, batch_size=batch_size)\\n\\n predictions = model.predict(eval_x, batch_size=batch_size)\\n auc = tf.metrics.auc(eval_y, predictions)\\n\\n print(\\\"Evaluation Loss:\\\", loss[0])\\n print(\\\"Accuracy:\\\", loss[1])\\n print(\\\"AUC: \\\", auc[0][1])\",\n \"def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:\\n # Initialize feature extractor\\n nltk.download('stopwords')\\n stop_words = set(stopwords.words('english'))\\n\\n if args.model == \\\"TRIVIAL\\\":\\n feat_extractor = None\\n elif args.feats == \\\"UNIGRAM\\\":\\n feat_extractor = UnigramFeatureExtractor(Indexer(), train_exs, stop_words)\\n elif args.feats == \\\"BIGRAM\\\":\\n # Add additional preprocessing code here\\n feat_extractor = BigramFeatureExtractor(Indexer(), train_exs, stop_words)\\n elif args.feats == \\\"BETTER\\\":\\n # Add additional preprocessing code here\\n feat_extractor = BetterFeatureExtractor(Indexer(), train_exs, stop_words)\\n else:\\n raise Exception(\\\"Pass in UNIGRAM, BIGRAM, or BETTER to run the appropriate system\\\")\\n\\n # Train the model\\n if args.model == \\\"TRIVIAL\\\":\\n model = TrivialSentimentClassifier()\\n elif args.model == \\\"PERCEPTRON\\\":\\n model = train_perceptron(train_exs, feat_extractor)\\n elif args.model == \\\"LR\\\":\\n model = train_logistic_regression(train_exs, feat_extractor)\\n else:\\n raise Exception(\\\"Pass in TRIVIAL, PERCEPTRON, or LR to run the appropriate system\\\")\\n return model\",\n \"def model_fn(features, labels, mode, params): # pylint: disable=unused-argument\\n\\n tf.logging.info(\\\"*** Features ***\\\")\\n for name in sorted(features.keys()):\\n tf.logging.info(\\\" name = %s, shape = %s\\\" % (name, features[name].shape))\\n\\n unique_ids = features[\\\"unique_ids\\\"]\\n input_ids = features[\\\"input_ids\\\"]\\n input_mask = features[\\\"input_mask\\\"]\\n segment_ids = features[\\\"segment_ids\\\"]\\n\\n is_training = (mode == tf.estimator.ModeKeys.TRAIN)\\n\\n logits = create_model(\\n bert_config=bert_config,\\n is_training=is_training,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n use_one_hot_embeddings=use_one_hot_embeddings)\\n\\n tvars = tf.trainable_variables()\\n\\n initialized_variable_names = {}\\n\\n if init_checkpoint:\\n (assignment_map, initialized_variable_names\\n ) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\\n\\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n\\n tf.logging.info(\\\"**** Trainable Variables ****\\\")\\n for var in tvars:\\n init_string = \\\"\\\"\\n if var.name in initialized_variable_names:\\n init_string = \\\", *INIT_FROM_CKPT*\\\"\\n tf.logging.info(\\\" name = %s, shape = %s%s\\\", var.name, var.shape,\\n init_string)\\n\\n output_spec = None\\n if mode == tf.estimator.ModeKeys.PREDICT:\\n predictions = {\\n \\\"unique_ids\\\": unique_ids,\\n \\\"prediction\\\": tf.argmax(logits, axis=-1),\\n }\\n output_spec = tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)\\n else:\\n def compute_loss(logits, positions):\\n one_hot_positions = tf.one_hot(\\n positions, depth=3, dtype=tf.float32)\\n log_probs = tf.nn.log_softmax(logits, axis=-1)\\n loss = -tf.reduce_mean(\\n tf.reduce_sum(one_hot_positions * log_probs, axis=-1))\\n return loss\\n\\n label = features[\\\"label\\\"]\\n\\n loss = compute_loss(logits, label)\\n predicted_classes = tf.argmax(logits, axis=-1)\\n accuracy = tf.metrics.accuracy(labels=label, predictions=predicted_classes, name='acc_op')\\n\\n # global global_acc_list\\n # global_acc_list.append(accuracy)\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n train_op = optimization.create_optimizer(\\n loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu)\\n\\n metrics = {'accuracy': accuracy}\\n output_spec = tf.estimator.EstimatorSpec(\\n mode=mode,\\n loss=loss,\\n eval_metric_ops=metrics,\\n train_op=train_op)\\n elif mode == tf.estimator.ModeKeys.EVAL:\\n metrics = {'accuracy': accuracy}\\n output_spec = tf.estimator.EstimatorSpec(mode, loss=loss, eval_metric_ops=metrics)\\n else:\\n raise ValueError(\\n \\\"Only TRAIN and PREDICT modes are supported: %s\\\" % (mode))\\n\\n return output_spec\",\n \"def _train(self, samples):\\n for i, sample in enumerate(samples):\\n # add extra info to samples\\n sample = {\\n 'src_tokens': sample[0],\\n 'input_tokens': self._right_shifted_ys(sample[1]),\\n 'target': sample[1],\\n 'id': None\\n }\\n sample['ntokens'] = sum(len(t) for t in sample['target'])\\n sample['src_positions'] = self._positions_for_tokens(\\n sample['src_tokens'])\\n sample['input_positions'] = self._positions_for_tokens(\\n sample['input_tokens'])\\n samples[i] = sample\\n return self.trainer.train_step(samples)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6938712","0.6882058","0.6713514","0.6688264","0.666646","0.6585662","0.6549936","0.6544408","0.65219134","0.6470889","0.6462349","0.64333606","0.643169","0.63435173","0.63322496","0.63154864","0.6292728","0.62925255","0.62748116","0.62622416","0.6249937","0.62396747","0.62396747","0.62396747","0.62396747","0.62396747","0.62262124","0.6220869","0.621164","0.6209424","0.62048054","0.62040836","0.6181354","0.6177827","0.61532426","0.6151822","0.61479306","0.61277825","0.611602","0.61124265","0.6112369","0.6111328","0.6098059","0.60951793","0.60900325","0.6089449","0.60882837","0.60882837","0.6087298","0.6087298","0.6087298","0.6087298","0.6087298","0.6084515","0.6069787","0.60633975","0.60499567","0.6047089","0.6044178","0.60144013","0.60118777","0.60109955","0.6008571","0.6005799","0.6005182","0.6004462","0.6004357","0.5993922","0.5992911","0.5984964","0.598301","0.5982757","0.59777653","0.5975726","0.5975264","0.5971497","0.59708774","0.5967617","0.59614855","0.59600365","0.59551334","0.59508115","0.593866","0.59369785","0.5935889","0.59350866","0.59250546","0.5911742","0.59077364","0.58893543","0.5886292","0.5886069","0.5876774","0.5876383","0.58750266","0.58746684","0.5873732","0.58693707","0.5868019","0.5863721"],"string":"[\n \"0.6938712\",\n \"0.6882058\",\n \"0.6713514\",\n \"0.6688264\",\n \"0.666646\",\n \"0.6585662\",\n \"0.6549936\",\n \"0.6544408\",\n \"0.65219134\",\n \"0.6470889\",\n \"0.6462349\",\n \"0.64333606\",\n \"0.643169\",\n \"0.63435173\",\n \"0.63322496\",\n \"0.63154864\",\n \"0.6292728\",\n \"0.62925255\",\n \"0.62748116\",\n \"0.62622416\",\n \"0.6249937\",\n \"0.62396747\",\n \"0.62396747\",\n \"0.62396747\",\n \"0.62396747\",\n \"0.62396747\",\n \"0.62262124\",\n \"0.6220869\",\n \"0.621164\",\n \"0.6209424\",\n \"0.62048054\",\n \"0.62040836\",\n \"0.6181354\",\n \"0.6177827\",\n \"0.61532426\",\n \"0.6151822\",\n \"0.61479306\",\n \"0.61277825\",\n \"0.611602\",\n \"0.61124265\",\n \"0.6112369\",\n \"0.6111328\",\n \"0.6098059\",\n \"0.60951793\",\n \"0.60900325\",\n \"0.6089449\",\n \"0.60882837\",\n \"0.60882837\",\n \"0.6087298\",\n \"0.6087298\",\n \"0.6087298\",\n \"0.6087298\",\n \"0.6087298\",\n \"0.6084515\",\n \"0.6069787\",\n \"0.60633975\",\n \"0.60499567\",\n \"0.6047089\",\n \"0.6044178\",\n \"0.60144013\",\n \"0.60118777\",\n \"0.60109955\",\n \"0.6008571\",\n \"0.6005799\",\n \"0.6005182\",\n \"0.6004462\",\n \"0.6004357\",\n \"0.5993922\",\n \"0.5992911\",\n \"0.5984964\",\n \"0.598301\",\n \"0.5982757\",\n \"0.59777653\",\n \"0.5975726\",\n \"0.5975264\",\n \"0.5971497\",\n \"0.59708774\",\n \"0.5967617\",\n \"0.59614855\",\n \"0.59600365\",\n \"0.59551334\",\n \"0.59508115\",\n \"0.593866\",\n \"0.59369785\",\n \"0.5935889\",\n \"0.59350866\",\n \"0.59250546\",\n \"0.5911742\",\n \"0.59077364\",\n \"0.58893543\",\n \"0.5886292\",\n \"0.5886069\",\n \"0.5876774\",\n \"0.5876383\",\n \"0.58750266\",\n \"0.58746684\",\n \"0.5873732\",\n \"0.58693707\",\n \"0.5868019\",\n \"0.5863721\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6190756"},"document_rank":{"kind":"string","value":"32"}}},{"rowIdx":14897,"cells":{"query":{"kind":"string","value":"Return the camera's mac address as the serial number."},"document":{"kind":"string","value":"def serial_number(self) -> str:\n return self.mac_address"},"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_mac_address(self):\n str_hex_mac = uuid.UUID(int=uuid.getnode()).hex[-12:]\n return str_hex_mac","def mac(self) -> str:\n return self.camera_info[\"wifi_mac\"]","def mac_address(self) -> str:\n return self._device.mac","def serial(self) -> str:\n return self.camera_info[\"device_sn\"]","def unique_id(self):\n return self._device.mac","def get_mac_string():\n mac_int = getnode()\n mac_str = ':'.join((\"%012x\" % mac_int)[i:i + 2] for i in range(0, 12, 2))\n return mac_str","def mac(self):\n return self.device.settings[\"device\"][\"mac\"]","def mac(self):\n return self.device.settings[\"device\"][\"mac\"]","def get_mac(self) -> str:\n hex_mac = hexlify(self.message)[160:172].decode().upper()\n return (\n hex_mac[0:2]\n + \":\"\n + hex_mac[2:4]\n + \":\"\n + hex_mac[4:6]\n + \":\"\n + hex_mac[6:8]\n + \":\"\n + hex_mac[8:10]\n + \":\"\n + hex_mac[10:12]\n )","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 )\n ifname = get_default_iface_name_linux()\n s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n info = fcntl.ioctl(s.fileno(), 0x8927,\n struct.pack('256s', bytes(ifname, 'utf-8')[:15]))\n return ''.join('%02x' % b for b in info[18:24])","def get_mac(self, node_id):\n nc = '%02x' % self.node_class\n nr_iface = '%02x' % self.nr_host_interface\n node_id = '%08x' % node_id\n\n return '%s:%s:%s:%s:%s:%s' % (nc, nr_iface, node_id[0:2], node_id[2:4], node_id[4:6], node_id[6:8])","def _get_mac(self):\n return self.__mac","def mac_address(self):\n mac = [\n self.random.randint(0x00, 0xff),\n self.random.randint(0x00, 0xff),\n self.random.randint(0x00, 0xff),\n self.random.randint(0x00, 0xff),\n self.random.randint(0x00, 0xff),\n self.random.randint(0x00, 0xff)\n ]\n return ':'.join(map(lambda x: f\"{x:02X}\", mac))","def person_mac(self):\n return self._person_mac","def get_mac_address():\n eth0_interface = 'eth0'\n addresses = netifaces.ifaddresses(eth0_interface)[netifaces.AF_LINK][0]\n mac_address = addresses['addr']\n return mac_address","def mac_address(self):\n return self._mac_address","def get_sonic_mac(host, asicnum, port):\n if host.facts[\"num_asic\"] == 1:\n cmd = \"sudo ip link show {}\".format(port)\n else:\n ns = \"asic\" + str(asicnum)\n cmd = \"sudo ip netns exec {} ip link show {}\".format(ns, port)\n output = host.command(cmd)\n mac = output['stdout_lines'][1].split()[1]\n logger.info(\"host: %s, asic: %d, port: %s, mac: %s\", host.hostname, asicnum, port, mac)\n return mac","def get_mac_address(self):\n\t\treturn call_sdk_function('PrlVmDevNet_GetMacAddress', self.handle)","def get_rand_mac(self):\n random_mac = []\n\n # add manufacturer\n random_mac.append(self.get_rand_manufact())\n\n # generate the last 24 bits of the random hex\n for i in range(0, 3):\n rand_digit1 = self.get_rand_hex_digit()\n rand_digit2 = self.get_rand_hex_digit()\n random_mac.append(rand_digit1 + rand_digit2)\n\n return ':'.join(random_mac)","def _mac_addr(address):\n return ':'.join('%02x' % ord(b) for b in address)","def get_mac():\n\n interface = [x for x in netifaces.interfaces() if 'wlan' in x or 'wlp' in x][0]\n return netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']","def get_mac(self) -> str:\n self.sendline(\"iw {} info\".format(self.iface_dut))\n # We are looking for MAC definition of STA\n # wdev 0x1\n # addr 96:4e:c9:cc:7a:2c\n # type managed\n self.expect(\"addr (?P<mac>..:..:..:..:..:..)\\r\\n\\t(type|ssid)\")\n return self.match.group('mac')","def mac(self):\n mac = hexlify(WLAN().config('mac'), ':').decode()\n return mac.upper() # MAC-address in upper case","def mac_ntoa(mac):\n return '%.2x:%.2x:%.2x:%.2x:%.2x:%.2x' % tuple(map(ord, list(mac)))","def get_mac(self) :\n\t\ttry :\n\t\t\treturn self.p_fields.f128\n\t\texcept :\n\t\t\treturn None","def macFor(cls, board):\n return cls.MAC_PREFIX + '{:02X}'.format(int(board))","def idn(self):\n hname = (ct.c_char * 100)()\n self.lib.GetHeadModel(ct.pointer(hname))\n hname = str(hname.value)[2:-1]\n sn = ct.c_uint()\n self.lib.GetCameraSerialNumber(ct.pointer(sn))\n return 'Andor ' + hname + ', serial number ' + str(sn.value)","def _get_mac_address(self, mac_numbers):\n\n mac = \"\"\n for num in mac_numbers:\n num = self._convert_to_hex(num)\n mac = ':'.join((mac, num))\n mac = mac[1:]\n return mac","def get_mac_address(self):\n\t\treturn call_sdk_function('PrlSrvCfgNet_GetMacAddress', self.handle)","def getMac(self):\n # Import netifaces here to prevent error importing this module in setup.py\n import netifaces\n interfaces = ['eth0', 'wlan0']\n try:\n interfaces.append(netifaces.gateways()['default'][netifaces.AF_INET][1])\n except:\n pass\n for interface in interfaces:\n try:\n return netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']\n except ValueError:\n pass\n except:\n exception('Error getting MAC address')\n return None","def random_mac():\n return '\"02:%02x:%02x:%02x:%02x:%02x\"' % (random.randint(0,255),\n random.randint(0,255),\n random.randint(0,255),\n random.randint(0,255),\n random.randint(0,255))","def get_serial_number(device):\n def to_base36(n, alphabet=\"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\"):\n return (to_base36(n // 36) + alphabet[n % 36]).lstrip(\"0\") \\\n if n > 0 else \"0\"\n\n a0000 = 604661760\n if device.SerialNumber >= a0000:\n return to_base36(device.SerialNumber)\n return str(device.SerialNumber)","def device_serial_number(self) -> str:\n return pulumi.get(self, \"device_serial_number\")","def device_serial_number(self) -> str:\n return pulumi.get(self, \"device_serial_number\")","def _serial_number(self):\n hops_config = self._configurations[TextualDevice.connection_hops]\n cfg_ux2adb = hops_config[UnixRemote.unix_remote][AdbRemote.adb_shell]\n serial_number = cfg_ux2adb[\"command_params\"][\"serial_number\"]\n return serial_number","def _get_entry_address(device_serial: str) -> str:\n comports = list_ports.comports()\n for com_port in comports:\n if com_port.serial_number == device_serial:\n return com_port.device.replace('/cu.', '/tty.')\n return ''","def station_serial(self) -> str:\n return self.camera_info[\"station_sn\"]","def sys_mac(self):\n try:\n with open(os.path.join(self.sys_class_path, \"address\")) as f:\n sys_mac = f.read().strip('\\0').strip()\n except Exception:\n sys.stderr.write(\"Failed to read address for entry: %s\\n\" %\n (self._orig_line))\n raise\n\n return sys_mac","def bmc_mac_address(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"bmc_mac_address\")","def macaddr(index):\n hname = name.encode(\"utf-8\") if not isinstance(name, bytes) else name\n mac_ext = hashlib.md5(hname).hexdigest() # pylint: disable=E1101\n return \"52:54:00:{0}:{1}:{2:02x}\".format(mac_ext[0:2], mac_ext[2:4], int(mac_ext[4:6], 16) ^ index)","def unique_id(self):\n return self._device.serial","def mac_from_vm(vm: libvirt.virDomain = None) -> str:\n doc = minidom.parseString(vm.XMLDesc())\n interfaces = doc.getElementsByTagName('mac')\n return interfaces[0].getAttribute('address')","def get_random_mac():\r\n mac = [0x00, 0x16, 0x3e,\r\n random.randint(0x00, 0x7f),\r\n random.randint(0x00, 0xff),\r\n random.randint(0x00, 0xff)]\r\n return ':'.join(map(lambda x: \"%02x\" % x, mac))","def _get_rmac(self):\n return self.__rmac","def get_mac_address(ifname):\n try:\n return open('/sys/class/net/' + ifname + '/address') \\\n .readline().strip()\n except:\n SysTools.logger.error(\"Failed to get mac-address of %s\", ifname)\n return \"00:00:00:00:00:00\"","def serial_number(self) -> Optional[str]:\n return self.profile_device.serial_number","def get_bound_card_mac(self):\n\t\treturn call_sdk_function('PrlVirtNet_GetBoundCardMac', self.handle)","def dest_mac(self):\n return self._dest_mac","def get_mac_address(self):\n self.__not_implemented()","def get_mac_address(self, result, host):\n if \"mac\" in result['scan'][host][\"addresses\"]:\n return result['scan'][host][\"addresses\"][\"mac\"]\n else:\n return \"\"","def sw_mac(self):\n return self.raw.get('sw_mac')","def serial_number(self):\n return self._dll.JLINKARM_GetSN()","def _getMac( self, bSeed ):\n\n\t\tbMac = ( bSeed >> 24 ) & 0xFF\n\t\treturn '%02X' % bMac","def serial_number(self):\n return self._packet.get('serial-number', '')","def generate_mac():\n rand_str = generate_name(choices=\"0123456789abcdef\", length=12)\n return \":\".join(re.findall(\"..\", rand_str))","def generate_mac():\n rand_str = generate_name(choices=\"0123456789abcdef\", length=12)\n return \":\".join(re.findall(\"..\", rand_str))","def set_mac_address(self, iface):\n if os.path.exists(\"/sys/class/net/%s\" % iface):\n return open(\"/sys/class/net/%s/address\" % iface).read().strip()\n return \"none\"","def set_mac_address(self, iface):\n if os.path.exists(\"/sys/class/net/%s\" % iface):\n return open(\"/sys/class/net/%s/address\" % iface).read().strip()\n return \"none\"","def get_mac_address(hostname):\n\n url = \"https://{}/redfish/v1/Managers/1/EthernetInterfaces/1/\".format(hostname)\n eth_dict = requests.get(url, auth=(USER,PASS),verify=False).json()\n mac_address = eth_dict['MACAddress']\n\n LOGGER.info(\"IPMI BMC %s reports MAC address as %s\", hostnameh, mac_address)\n\n return mac_address","def unique_id(self):\n return f\"{self._mac_address}:{self._device_id}:{self._zone_id}:switch\"","def _usb_serial_number(self):\n return self.device.serial_number","def get_device_name(self):\n name = self._device[\"name\"]\n if not name or name == \"--\":\n name = self._mac\n\n return name","def mac_addr(address):\n\tprint(':'.join('%02x' % compat_ord(b) for b in address))\n\treturn ':'.join('%s' % format(compat_ord(b), '0>8b') for b in address)","def get_sys_mac_address():\n mac = \"00:00:00:00:00:00\"\n try:\n if os.path.exists(SysTools.SYS_MAC_FILE):\n with open(SysTools.SYS_MAC_FILE, 'r') as fd:\n mac = fd.readline().strip()\n except:\n SysTools.logger.error(\"Failed to get sys-mac-address from %s\",\n SysTools.SYS_MAC_FILE)\n return mac","def get_device_id(self) -> str:\n return hexlify(self.message)[36:42].decode()","def get_address(self):\n self.rs485.clear_buffers()\n self.rs485.write_command('#00?0')\n response = self.rs485.read_response()\n pattern = '\\$.*? (.*?) \\r\\n'\n hexval = re.findall(pattern,response).pop()\n address = int(hexval,16)\n return address","def mac_string(self) :\n\t\tif not getattr(self,'pkg02') :\n\t\t\treturn None \n\t\tif self.pkg02[:2] not in ['01','02','04','05' ] :\n\t\t\treturn None\n\t\treturn self.pkg02 + ' ' + self.p_fields.mac_string()","def to_mac(self):\n ts_type = self.ts_types['mac']\n try:\n dt_obj = duparser.parse(self.timestamp)\n if hasattr(dt_obj.tzinfo, '_offset'):\n dt_tz = dt_obj.tzinfo._offset.total_seconds()\n dt_obj = duparser.parse(self.timestamp, ignoretz=True)\n else:\n dt_tz = 0\n self.out_mac = str(int((dt_obj - self.epoch_2001).total_seconds() - int(dt_tz)))\n ts_output = str(\"{}\\t\\t{}\".format(ts_type, self.out_mac))\n except Exception:\n exc_type, exc_obj, exc_tb = sys.exc_info()\n print(str(exc_type) + \" - \" + str(exc_obj) + \" - line \" + str(exc_tb.tb_lineno))\n self.out_mac = ts_output = False\n return self.out_mac, ts_output","def unique_id(self) -> str:\n return f\"{self._device.mac}_{self._router.config_entry.entry_id}\"","def get_serial(self) -> str:\n return self._get_string(openvr.Prop_SerialNumber_String)","def get_eth0_mac_address(hostname):\n\n command = \"ipmitool -H {} -U ADMIN -P ADMIN raw 0x30 0x21\".format(hostname)\n\n try:\n result = subprocess.check_output(command, shell=True)\n except subprocess.CalledProcessError as exc:\n LOGGER.exception(\"Failed to get eth0 mac for %s\", hostname)\n\n # Remove space and newline\n result = result.strip()\n mac = \":\".join(result.split()[4:]) # No verification :-(\n\n return mac","def name(self) -> str:\n return self._device.name or self._device.mac","def get_serial_number(self):\n\n\t\treturn struct.unpack('<Q', self.boot_sector_data[72 : 80])[0]","def mac_addr(address):\n return ':'.join('%02x' % compat_ord(b) for b in address)","def mac_addr(address):\n return ':'.join('%02x' % compat_ord(b) for b in address)","def mac_addr(address):\n return ':'.join('%02x' % compat_ord(b) for b in address)","def mac_addr(address):\n return ':'.join('%02x' % compat_ord(b) for b in address)","def _generate_machine_id(self):\r\n mach_id = \"machine_\"\r\n try:\r\n gws = netifaces.gateways() # get all gateways\r\n default = gws['default'] # get the default gw\r\n adapter = default[2][1] # get the adapter identifier\r\n real_adapter = netifaces.ifaddresses(adapter) # get the adapter\r\n link_info = real_adapter[netifaces.AF_LINK]\r\n mac = link_info[0]['addr']\r\n mac = re.sub('[:]', '', mac)\r\n except:\r\n mac = \"unsup\"\r\n self.logger.error(\"Getting mac of internet card is not supported, needs netifaces >= 0.10\")\r\n self.machine_id = mach_id + mac","def to_mac(self):\n try:\n dt_obj = duparser.parse(timestamp)\n self.out_mac = str(int((dt_obj - self.epoch_2001).total_seconds()))\n except Exception as e:\n if not args.log:\n pass\n else:\n logging.error(str(type(e)) + \",\" + str(e))\n self.out_mac = False\n return self.out_mac","def mac_address(self):\n if self._mac_address is None:\n expression = expressions.WPA_MAC\n name = expressions.MAC_ADDRESS_NAME\n command = self.status_command\n self._mac_address = self._match(expression,\n name,\n command)\n return self._mac_address","def unique_id(self) -> str:\n return '{0}_{1}'.format(self._mac.replace(':', ''), self.entity_id)","def get_serial_number() -> str:\r\n cpuserial = \"0000000000000000\"\r\n try:\r\n with open('/proc/cpuinfo', 'r') as file:\r\n for line in file:\r\n if line[0:6]=='Serial':\r\n cpuserial = line[10:26]\r\n except FileNotFoundError:\r\n cpuserial = \"ERROR000000000\"\r\n logger.error(\"Cannot get serial number\")\r\n\r\n return cpuserial","def get_base_mac(self):\n raise NotImplementedError","def generate_random_mac_addr(self):\n return \"02:00:00:%02x:%02x:%02x\" % (random.randint(0, 255),\n random.randint(0, 255),\n random.randint(0, 255))","def get_device_sn(self):\n summary = self.get_version_summary()\n pattern = '\\$.*? .*? .*? (.*?) .*? .*? .*? .*? .*? \\r\\n' \n mcu_sn = int(re.findall(pattern,summary).pop())\n return mcu_sn","def get_macaddr(self):\n return self.macaddr","def boot_mac_address(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"boot_mac_address\")","def get_machine_id(self):\n try:\n self.boardcon.flushInput()\n self._write(chr(self.outgoing_machine_id))\n sleep(0.5)\n machine_id = ord(self._read(1))\n logger.info(\"Mapped /dev/ttyUSB{0} to Mac ID {1}\".format(\n self.dev_id, machine_id\n ))\n return int(machine_id)\n except Exception as e:\n error_msg = \"No Machine ID received from /dev/ttyUSB{0}.\".format(\n self.dev_id\n )\n logger.error(error_msg)\n raise DeviceConnectionException(error_msg)","def __str__(self):\n return '0x{0:x}'.format(self._device_ptr)","def emulab_mac(mac):\n\n return \"\".join(mac.lower().split(':'))","def MacAddress(self):\n if self.force_auto_sync:\n self.get('MacAddress')\n return self._MacAddress","def get_random_mac():\n\t\n\t# use the Dlink range\n\tmac = \"00:05:5D\"\n\t\n\tfor i in range(0,3):\n\t\tmac += \":%s\" % hex(random.randrange(0,256))[2:]\n\t\t\n\t\t\n\treturn mac","def get_probable_router_mac(self):\n return self.probable_router_mac","def bytes_to_mac_str(buff):\n if len(buff) != DataDescription.B_SEQ_MAC_LEN:\n raise TypeError(\"Invalid input\")\n return \"%02X:%02X:%02X:%02X:%02X:%02X\" % buff","def name(self):\n return f\"{self.sensor_type['name']} ({self._mac[-5:]})\"","def get_current_mac(interface):\r\n ifconfig_result = subprocess.check_output([\"sudo\", \"ifconfig\", interface])\r\n mac_result = re.search(r\"\\w\\w:\\w\\w:\\w\\w:\\w\\w:\\w\\w:\\w\\w\", ifconfig_result.decode('utf-8'))\r\n if mac_result:\r\n return mac_result.group(0)\r\n else:\r\n print(\"Could not read MAC-address\")","def Serial(self):\n ret,buf= self.Bus.Transaction(chr(self.Address+1)+chr(Serial),0x06)\n return struct.unpack(\">L\", buf[2:6])[0]","def mac(self):\n if not self.is_rule:\n raise NotRuleError(\"No 'ATTR{address}' field.\")\n\n if \"ATTR{address}\" not in self._fields:\n raise NotRule70Error(\"No 'ATTR{address}' field.\")\n\n return self._fields[\"ATTR{address}\"]","def generate_mac_addr(self):\n\t\tcall_sdk_function('PrlVmDevNet_GenerateMacAddr', self.handle)","def name(self) -> str:\n return self.camera_info[\"device_name\"]"],"string":"[\n \"def __get_mac_address(self):\\n str_hex_mac = uuid.UUID(int=uuid.getnode()).hex[-12:]\\n return str_hex_mac\",\n \"def mac(self) -> str:\\n return self.camera_info[\\\"wifi_mac\\\"]\",\n \"def mac_address(self) -> str:\\n return self._device.mac\",\n \"def serial(self) -> str:\\n return self.camera_info[\\\"device_sn\\\"]\",\n \"def unique_id(self):\\n return self._device.mac\",\n \"def get_mac_string():\\n mac_int = getnode()\\n mac_str = ':'.join((\\\"%012x\\\" % mac_int)[i:i + 2] for i in range(0, 12, 2))\\n return mac_str\",\n \"def mac(self):\\n return self.device.settings[\\\"device\\\"][\\\"mac\\\"]\",\n \"def mac(self):\\n return self.device.settings[\\\"device\\\"][\\\"mac\\\"]\",\n \"def get_mac(self) -> str:\\n hex_mac = hexlify(self.message)[160:172].decode().upper()\\n return (\\n hex_mac[0:2]\\n + \\\":\\\"\\n + hex_mac[2:4]\\n + \\\":\\\"\\n + hex_mac[4:6]\\n + \\\":\\\"\\n + hex_mac[6:8]\\n + \\\":\\\"\\n + hex_mac[8:10]\\n + \\\":\\\"\\n + hex_mac[10:12]\\n )\",\n \"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 )\\n ifname = get_default_iface_name_linux()\\n s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n info = fcntl.ioctl(s.fileno(), 0x8927,\\n struct.pack('256s', bytes(ifname, 'utf-8')[:15]))\\n return ''.join('%02x' % b for b in info[18:24])\",\n \"def get_mac(self, node_id):\\n nc = '%02x' % self.node_class\\n nr_iface = '%02x' % self.nr_host_interface\\n node_id = '%08x' % node_id\\n\\n return '%s:%s:%s:%s:%s:%s' % (nc, nr_iface, node_id[0:2], node_id[2:4], node_id[4:6], node_id[6:8])\",\n \"def _get_mac(self):\\n return self.__mac\",\n \"def mac_address(self):\\n mac = [\\n self.random.randint(0x00, 0xff),\\n self.random.randint(0x00, 0xff),\\n self.random.randint(0x00, 0xff),\\n self.random.randint(0x00, 0xff),\\n self.random.randint(0x00, 0xff),\\n self.random.randint(0x00, 0xff)\\n ]\\n return ':'.join(map(lambda x: f\\\"{x:02X}\\\", mac))\",\n \"def person_mac(self):\\n return self._person_mac\",\n \"def get_mac_address():\\n eth0_interface = 'eth0'\\n addresses = netifaces.ifaddresses(eth0_interface)[netifaces.AF_LINK][0]\\n mac_address = addresses['addr']\\n return mac_address\",\n \"def mac_address(self):\\n return self._mac_address\",\n \"def get_sonic_mac(host, asicnum, port):\\n if host.facts[\\\"num_asic\\\"] == 1:\\n cmd = \\\"sudo ip link show {}\\\".format(port)\\n else:\\n ns = \\\"asic\\\" + str(asicnum)\\n cmd = \\\"sudo ip netns exec {} ip link show {}\\\".format(ns, port)\\n output = host.command(cmd)\\n mac = output['stdout_lines'][1].split()[1]\\n logger.info(\\\"host: %s, asic: %d, port: %s, mac: %s\\\", host.hostname, asicnum, port, mac)\\n return mac\",\n \"def get_mac_address(self):\\n\\t\\treturn call_sdk_function('PrlVmDevNet_GetMacAddress', self.handle)\",\n \"def get_rand_mac(self):\\n random_mac = []\\n\\n # add manufacturer\\n random_mac.append(self.get_rand_manufact())\\n\\n # generate the last 24 bits of the random hex\\n for i in range(0, 3):\\n rand_digit1 = self.get_rand_hex_digit()\\n rand_digit2 = self.get_rand_hex_digit()\\n random_mac.append(rand_digit1 + rand_digit2)\\n\\n return ':'.join(random_mac)\",\n \"def _mac_addr(address):\\n return ':'.join('%02x' % ord(b) for b in address)\",\n \"def get_mac():\\n\\n interface = [x for x in netifaces.interfaces() if 'wlan' in x or 'wlp' in x][0]\\n return netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']\",\n \"def get_mac(self) -> str:\\n self.sendline(\\\"iw {} info\\\".format(self.iface_dut))\\n # We are looking for MAC definition of STA\\n # wdev 0x1\\n # addr 96:4e:c9:cc:7a:2c\\n # type managed\\n self.expect(\\\"addr (?P<mac>..:..:..:..:..:..)\\\\r\\\\n\\\\t(type|ssid)\\\")\\n return self.match.group('mac')\",\n \"def mac(self):\\n mac = hexlify(WLAN().config('mac'), ':').decode()\\n return mac.upper() # MAC-address in upper case\",\n \"def mac_ntoa(mac):\\n return '%.2x:%.2x:%.2x:%.2x:%.2x:%.2x' % tuple(map(ord, list(mac)))\",\n \"def get_mac(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self.p_fields.f128\\n\\t\\texcept :\\n\\t\\t\\treturn None\",\n \"def macFor(cls, board):\\n return cls.MAC_PREFIX + '{:02X}'.format(int(board))\",\n \"def idn(self):\\n hname = (ct.c_char * 100)()\\n self.lib.GetHeadModel(ct.pointer(hname))\\n hname = str(hname.value)[2:-1]\\n sn = ct.c_uint()\\n self.lib.GetCameraSerialNumber(ct.pointer(sn))\\n return 'Andor ' + hname + ', serial number ' + str(sn.value)\",\n \"def _get_mac_address(self, mac_numbers):\\n\\n mac = \\\"\\\"\\n for num in mac_numbers:\\n num = self._convert_to_hex(num)\\n mac = ':'.join((mac, num))\\n mac = mac[1:]\\n return mac\",\n \"def get_mac_address(self):\\n\\t\\treturn call_sdk_function('PrlSrvCfgNet_GetMacAddress', self.handle)\",\n \"def getMac(self):\\n # Import netifaces here to prevent error importing this module in setup.py\\n import netifaces\\n interfaces = ['eth0', 'wlan0']\\n try:\\n interfaces.append(netifaces.gateways()['default'][netifaces.AF_INET][1])\\n except:\\n pass\\n for interface in interfaces:\\n try:\\n return netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']\\n except ValueError:\\n pass\\n except:\\n exception('Error getting MAC address')\\n return None\",\n \"def random_mac():\\n return '\\\"02:%02x:%02x:%02x:%02x:%02x\\\"' % (random.randint(0,255),\\n random.randint(0,255),\\n random.randint(0,255),\\n random.randint(0,255),\\n random.randint(0,255))\",\n \"def get_serial_number(device):\\n def to_base36(n, alphabet=\\\"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\\\"):\\n return (to_base36(n // 36) + alphabet[n % 36]).lstrip(\\\"0\\\") \\\\\\n if n > 0 else \\\"0\\\"\\n\\n a0000 = 604661760\\n if device.SerialNumber >= a0000:\\n return to_base36(device.SerialNumber)\\n return str(device.SerialNumber)\",\n \"def device_serial_number(self) -> str:\\n return pulumi.get(self, \\\"device_serial_number\\\")\",\n \"def device_serial_number(self) -> str:\\n return pulumi.get(self, \\\"device_serial_number\\\")\",\n \"def _serial_number(self):\\n hops_config = self._configurations[TextualDevice.connection_hops]\\n cfg_ux2adb = hops_config[UnixRemote.unix_remote][AdbRemote.adb_shell]\\n serial_number = cfg_ux2adb[\\\"command_params\\\"][\\\"serial_number\\\"]\\n return serial_number\",\n \"def _get_entry_address(device_serial: str) -> str:\\n comports = list_ports.comports()\\n for com_port in comports:\\n if com_port.serial_number == device_serial:\\n return com_port.device.replace('/cu.', '/tty.')\\n return ''\",\n \"def station_serial(self) -> str:\\n return self.camera_info[\\\"station_sn\\\"]\",\n \"def sys_mac(self):\\n try:\\n with open(os.path.join(self.sys_class_path, \\\"address\\\")) as f:\\n sys_mac = f.read().strip('\\\\0').strip()\\n except Exception:\\n sys.stderr.write(\\\"Failed to read address for entry: %s\\\\n\\\" %\\n (self._orig_line))\\n raise\\n\\n return sys_mac\",\n \"def bmc_mac_address(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"bmc_mac_address\\\")\",\n \"def macaddr(index):\\n hname = name.encode(\\\"utf-8\\\") if not isinstance(name, bytes) else name\\n mac_ext = hashlib.md5(hname).hexdigest() # pylint: disable=E1101\\n return \\\"52:54:00:{0}:{1}:{2:02x}\\\".format(mac_ext[0:2], mac_ext[2:4], int(mac_ext[4:6], 16) ^ index)\",\n \"def unique_id(self):\\n return self._device.serial\",\n \"def mac_from_vm(vm: libvirt.virDomain = None) -> str:\\n doc = minidom.parseString(vm.XMLDesc())\\n interfaces = doc.getElementsByTagName('mac')\\n return interfaces[0].getAttribute('address')\",\n \"def get_random_mac():\\r\\n mac = [0x00, 0x16, 0x3e,\\r\\n random.randint(0x00, 0x7f),\\r\\n random.randint(0x00, 0xff),\\r\\n random.randint(0x00, 0xff)]\\r\\n return ':'.join(map(lambda x: \\\"%02x\\\" % x, mac))\",\n \"def _get_rmac(self):\\n return self.__rmac\",\n \"def get_mac_address(ifname):\\n try:\\n return open('/sys/class/net/' + ifname + '/address') \\\\\\n .readline().strip()\\n except:\\n SysTools.logger.error(\\\"Failed to get mac-address of %s\\\", ifname)\\n return \\\"00:00:00:00:00:00\\\"\",\n \"def serial_number(self) -> Optional[str]:\\n return self.profile_device.serial_number\",\n \"def get_bound_card_mac(self):\\n\\t\\treturn call_sdk_function('PrlVirtNet_GetBoundCardMac', self.handle)\",\n \"def dest_mac(self):\\n return self._dest_mac\",\n \"def get_mac_address(self):\\n self.__not_implemented()\",\n \"def get_mac_address(self, result, host):\\n if \\\"mac\\\" in result['scan'][host][\\\"addresses\\\"]:\\n return result['scan'][host][\\\"addresses\\\"][\\\"mac\\\"]\\n else:\\n return \\\"\\\"\",\n \"def sw_mac(self):\\n return self.raw.get('sw_mac')\",\n \"def serial_number(self):\\n return self._dll.JLINKARM_GetSN()\",\n \"def _getMac( self, bSeed ):\\n\\n\\t\\tbMac = ( bSeed >> 24 ) & 0xFF\\n\\t\\treturn '%02X' % bMac\",\n \"def serial_number(self):\\n return self._packet.get('serial-number', '')\",\n \"def generate_mac():\\n rand_str = generate_name(choices=\\\"0123456789abcdef\\\", length=12)\\n return \\\":\\\".join(re.findall(\\\"..\\\", rand_str))\",\n \"def generate_mac():\\n rand_str = generate_name(choices=\\\"0123456789abcdef\\\", length=12)\\n return \\\":\\\".join(re.findall(\\\"..\\\", rand_str))\",\n \"def set_mac_address(self, iface):\\n if os.path.exists(\\\"/sys/class/net/%s\\\" % iface):\\n return open(\\\"/sys/class/net/%s/address\\\" % iface).read().strip()\\n return \\\"none\\\"\",\n \"def set_mac_address(self, iface):\\n if os.path.exists(\\\"/sys/class/net/%s\\\" % iface):\\n return open(\\\"/sys/class/net/%s/address\\\" % iface).read().strip()\\n return \\\"none\\\"\",\n \"def get_mac_address(hostname):\\n\\n url = \\\"https://{}/redfish/v1/Managers/1/EthernetInterfaces/1/\\\".format(hostname)\\n eth_dict = requests.get(url, auth=(USER,PASS),verify=False).json()\\n mac_address = eth_dict['MACAddress']\\n\\n LOGGER.info(\\\"IPMI BMC %s reports MAC address as %s\\\", hostnameh, mac_address)\\n\\n return mac_address\",\n \"def unique_id(self):\\n return f\\\"{self._mac_address}:{self._device_id}:{self._zone_id}:switch\\\"\",\n \"def _usb_serial_number(self):\\n return self.device.serial_number\",\n \"def get_device_name(self):\\n name = self._device[\\\"name\\\"]\\n if not name or name == \\\"--\\\":\\n name = self._mac\\n\\n return name\",\n \"def mac_addr(address):\\n\\tprint(':'.join('%02x' % compat_ord(b) for b in address))\\n\\treturn ':'.join('%s' % format(compat_ord(b), '0>8b') for b in address)\",\n \"def get_sys_mac_address():\\n mac = \\\"00:00:00:00:00:00\\\"\\n try:\\n if os.path.exists(SysTools.SYS_MAC_FILE):\\n with open(SysTools.SYS_MAC_FILE, 'r') as fd:\\n mac = fd.readline().strip()\\n except:\\n SysTools.logger.error(\\\"Failed to get sys-mac-address from %s\\\",\\n SysTools.SYS_MAC_FILE)\\n return mac\",\n \"def get_device_id(self) -> str:\\n return hexlify(self.message)[36:42].decode()\",\n \"def get_address(self):\\n self.rs485.clear_buffers()\\n self.rs485.write_command('#00?0')\\n response = self.rs485.read_response()\\n pattern = '\\\\$.*? (.*?) \\\\r\\\\n'\\n hexval = re.findall(pattern,response).pop()\\n address = int(hexval,16)\\n return address\",\n \"def mac_string(self) :\\n\\t\\tif not getattr(self,'pkg02') :\\n\\t\\t\\treturn None \\n\\t\\tif self.pkg02[:2] not in ['01','02','04','05' ] :\\n\\t\\t\\treturn None\\n\\t\\treturn self.pkg02 + ' ' + self.p_fields.mac_string()\",\n \"def to_mac(self):\\n ts_type = self.ts_types['mac']\\n try:\\n dt_obj = duparser.parse(self.timestamp)\\n if hasattr(dt_obj.tzinfo, '_offset'):\\n dt_tz = dt_obj.tzinfo._offset.total_seconds()\\n dt_obj = duparser.parse(self.timestamp, ignoretz=True)\\n else:\\n dt_tz = 0\\n self.out_mac = str(int((dt_obj - self.epoch_2001).total_seconds() - int(dt_tz)))\\n ts_output = str(\\\"{}\\\\t\\\\t{}\\\".format(ts_type, self.out_mac))\\n except Exception:\\n exc_type, exc_obj, exc_tb = sys.exc_info()\\n print(str(exc_type) + \\\" - \\\" + str(exc_obj) + \\\" - line \\\" + str(exc_tb.tb_lineno))\\n self.out_mac = ts_output = False\\n return self.out_mac, ts_output\",\n \"def unique_id(self) -> str:\\n return f\\\"{self._device.mac}_{self._router.config_entry.entry_id}\\\"\",\n \"def get_serial(self) -> str:\\n return self._get_string(openvr.Prop_SerialNumber_String)\",\n \"def get_eth0_mac_address(hostname):\\n\\n command = \\\"ipmitool -H {} -U ADMIN -P ADMIN raw 0x30 0x21\\\".format(hostname)\\n\\n try:\\n result = subprocess.check_output(command, shell=True)\\n except subprocess.CalledProcessError as exc:\\n LOGGER.exception(\\\"Failed to get eth0 mac for %s\\\", hostname)\\n\\n # Remove space and newline\\n result = result.strip()\\n mac = \\\":\\\".join(result.split()[4:]) # No verification :-(\\n\\n return mac\",\n \"def name(self) -> str:\\n return self._device.name or self._device.mac\",\n \"def get_serial_number(self):\\n\\n\\t\\treturn struct.unpack('<Q', self.boot_sector_data[72 : 80])[0]\",\n \"def mac_addr(address):\\n return ':'.join('%02x' % compat_ord(b) for b in address)\",\n \"def mac_addr(address):\\n return ':'.join('%02x' % compat_ord(b) for b in address)\",\n \"def mac_addr(address):\\n return ':'.join('%02x' % compat_ord(b) for b in address)\",\n \"def mac_addr(address):\\n return ':'.join('%02x' % compat_ord(b) for b in address)\",\n \"def _generate_machine_id(self):\\r\\n mach_id = \\\"machine_\\\"\\r\\n try:\\r\\n gws = netifaces.gateways() # get all gateways\\r\\n default = gws['default'] # get the default gw\\r\\n adapter = default[2][1] # get the adapter identifier\\r\\n real_adapter = netifaces.ifaddresses(adapter) # get the adapter\\r\\n link_info = real_adapter[netifaces.AF_LINK]\\r\\n mac = link_info[0]['addr']\\r\\n mac = re.sub('[:]', '', mac)\\r\\n except:\\r\\n mac = \\\"unsup\\\"\\r\\n self.logger.error(\\\"Getting mac of internet card is not supported, needs netifaces >= 0.10\\\")\\r\\n self.machine_id = mach_id + mac\",\n \"def to_mac(self):\\n try:\\n dt_obj = duparser.parse(timestamp)\\n self.out_mac = str(int((dt_obj - self.epoch_2001).total_seconds()))\\n except Exception as e:\\n if not args.log:\\n pass\\n else:\\n logging.error(str(type(e)) + \\\",\\\" + str(e))\\n self.out_mac = False\\n return self.out_mac\",\n \"def mac_address(self):\\n if self._mac_address is None:\\n expression = expressions.WPA_MAC\\n name = expressions.MAC_ADDRESS_NAME\\n command = self.status_command\\n self._mac_address = self._match(expression,\\n name,\\n command)\\n return self._mac_address\",\n \"def unique_id(self) -> str:\\n return '{0}_{1}'.format(self._mac.replace(':', ''), self.entity_id)\",\n \"def get_serial_number() -> str:\\r\\n cpuserial = \\\"0000000000000000\\\"\\r\\n try:\\r\\n with open('/proc/cpuinfo', 'r') as file:\\r\\n for line in file:\\r\\n if line[0:6]=='Serial':\\r\\n cpuserial = line[10:26]\\r\\n except FileNotFoundError:\\r\\n cpuserial = \\\"ERROR000000000\\\"\\r\\n logger.error(\\\"Cannot get serial number\\\")\\r\\n\\r\\n return cpuserial\",\n \"def get_base_mac(self):\\n raise NotImplementedError\",\n \"def generate_random_mac_addr(self):\\n return \\\"02:00:00:%02x:%02x:%02x\\\" % (random.randint(0, 255),\\n random.randint(0, 255),\\n random.randint(0, 255))\",\n \"def get_device_sn(self):\\n summary = self.get_version_summary()\\n pattern = '\\\\$.*? .*? .*? (.*?) .*? .*? .*? .*? .*? \\\\r\\\\n' \\n mcu_sn = int(re.findall(pattern,summary).pop())\\n return mcu_sn\",\n \"def get_macaddr(self):\\n return self.macaddr\",\n \"def boot_mac_address(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"boot_mac_address\\\")\",\n \"def get_machine_id(self):\\n try:\\n self.boardcon.flushInput()\\n self._write(chr(self.outgoing_machine_id))\\n sleep(0.5)\\n machine_id = ord(self._read(1))\\n logger.info(\\\"Mapped /dev/ttyUSB{0} to Mac ID {1}\\\".format(\\n self.dev_id, machine_id\\n ))\\n return int(machine_id)\\n except Exception as e:\\n error_msg = \\\"No Machine ID received from /dev/ttyUSB{0}.\\\".format(\\n self.dev_id\\n )\\n logger.error(error_msg)\\n raise DeviceConnectionException(error_msg)\",\n \"def __str__(self):\\n return '0x{0:x}'.format(self._device_ptr)\",\n \"def emulab_mac(mac):\\n\\n return \\\"\\\".join(mac.lower().split(':'))\",\n \"def MacAddress(self):\\n if self.force_auto_sync:\\n self.get('MacAddress')\\n return self._MacAddress\",\n \"def get_random_mac():\\n\\t\\n\\t# use the Dlink range\\n\\tmac = \\\"00:05:5D\\\"\\n\\t\\n\\tfor i in range(0,3):\\n\\t\\tmac += \\\":%s\\\" % hex(random.randrange(0,256))[2:]\\n\\t\\t\\n\\t\\t\\n\\treturn mac\",\n \"def get_probable_router_mac(self):\\n return self.probable_router_mac\",\n \"def bytes_to_mac_str(buff):\\n if len(buff) != DataDescription.B_SEQ_MAC_LEN:\\n raise TypeError(\\\"Invalid input\\\")\\n return \\\"%02X:%02X:%02X:%02X:%02X:%02X\\\" % buff\",\n \"def name(self):\\n return f\\\"{self.sensor_type['name']} ({self._mac[-5:]})\\\"\",\n \"def get_current_mac(interface):\\r\\n ifconfig_result = subprocess.check_output([\\\"sudo\\\", \\\"ifconfig\\\", interface])\\r\\n mac_result = re.search(r\\\"\\\\w\\\\w:\\\\w\\\\w:\\\\w\\\\w:\\\\w\\\\w:\\\\w\\\\w:\\\\w\\\\w\\\", ifconfig_result.decode('utf-8'))\\r\\n if mac_result:\\r\\n return mac_result.group(0)\\r\\n else:\\r\\n print(\\\"Could not read MAC-address\\\")\",\n \"def Serial(self):\\n ret,buf= self.Bus.Transaction(chr(self.Address+1)+chr(Serial),0x06)\\n return struct.unpack(\\\">L\\\", buf[2:6])[0]\",\n \"def mac(self):\\n if not self.is_rule:\\n raise NotRuleError(\\\"No 'ATTR{address}' field.\\\")\\n\\n if \\\"ATTR{address}\\\" not in self._fields:\\n raise NotRule70Error(\\\"No 'ATTR{address}' field.\\\")\\n\\n return self._fields[\\\"ATTR{address}\\\"]\",\n \"def generate_mac_addr(self):\\n\\t\\tcall_sdk_function('PrlVmDevNet_GenerateMacAddr', self.handle)\",\n \"def name(self) -> str:\\n return self.camera_info[\\\"device_name\\\"]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74284977","0.7396035","0.7244921","0.7241079","0.7186397","0.71549183","0.6929182","0.6929182","0.68750423","0.686168","0.6835941","0.6835715","0.68190706","0.67833877","0.6717112","0.6596283","0.65792704","0.6549326","0.6522258","0.6508936","0.6494126","0.6475544","0.6457014","0.6446254","0.64233387","0.64109164","0.64090216","0.63519794","0.63443905","0.6301198","0.6295915","0.6290527","0.6278506","0.6278506","0.6271986","0.6266944","0.62566864","0.62516445","0.62514544","0.62286717","0.6223271","0.62157404","0.6194412","0.61850977","0.6184888","0.61838806","0.61658484","0.6164103","0.6138218","0.61311543","0.6123015","0.61007077","0.6090908","0.60788685","0.6076587","0.6076587","0.60478234","0.60478234","0.60383457","0.6033365","0.60298055","0.60265315","0.6020329","0.60188586","0.6009554","0.60047257","0.5990516","0.59678906","0.5967045","0.5956476","0.5950644","0.59378815","0.59363514","0.5932797","0.5932797","0.5932797","0.5932797","0.5931605","0.59039545","0.5903498","0.58930105","0.5885581","0.587707","0.58760124","0.58747226","0.5871558","0.5869688","0.5868244","0.58660775","0.58599275","0.5842179","0.5840974","0.5839214","0.58316386","0.5831496","0.58228415","0.5801584","0.57942504","0.57933116","0.5763543"],"string":"[\n \"0.74284977\",\n \"0.7396035\",\n \"0.7244921\",\n \"0.7241079\",\n \"0.7186397\",\n \"0.71549183\",\n \"0.6929182\",\n \"0.6929182\",\n \"0.68750423\",\n \"0.686168\",\n \"0.6835941\",\n \"0.6835715\",\n \"0.68190706\",\n \"0.67833877\",\n \"0.6717112\",\n \"0.6596283\",\n \"0.65792704\",\n \"0.6549326\",\n \"0.6522258\",\n \"0.6508936\",\n \"0.6494126\",\n \"0.6475544\",\n \"0.6457014\",\n \"0.6446254\",\n \"0.64233387\",\n \"0.64109164\",\n \"0.64090216\",\n \"0.63519794\",\n \"0.63443905\",\n \"0.6301198\",\n \"0.6295915\",\n \"0.6290527\",\n \"0.6278506\",\n \"0.6278506\",\n \"0.6271986\",\n \"0.6266944\",\n \"0.62566864\",\n \"0.62516445\",\n \"0.62514544\",\n \"0.62286717\",\n \"0.6223271\",\n \"0.62157404\",\n \"0.6194412\",\n \"0.61850977\",\n \"0.6184888\",\n \"0.61838806\",\n \"0.61658484\",\n \"0.6164103\",\n \"0.6138218\",\n \"0.61311543\",\n \"0.6123015\",\n \"0.61007077\",\n \"0.6090908\",\n \"0.60788685\",\n \"0.6076587\",\n \"0.6076587\",\n \"0.60478234\",\n \"0.60478234\",\n \"0.60383457\",\n \"0.6033365\",\n \"0.60298055\",\n \"0.60265315\",\n \"0.6020329\",\n \"0.60188586\",\n \"0.6009554\",\n \"0.60047257\",\n \"0.5990516\",\n \"0.59678906\",\n \"0.5967045\",\n \"0.5956476\",\n \"0.5950644\",\n \"0.59378815\",\n \"0.59363514\",\n \"0.5932797\",\n \"0.5932797\",\n \"0.5932797\",\n \"0.5932797\",\n \"0.5931605\",\n \"0.59039545\",\n \"0.5903498\",\n \"0.58930105\",\n \"0.5885581\",\n \"0.587707\",\n \"0.58760124\",\n \"0.58747226\",\n \"0.5871558\",\n \"0.5869688\",\n \"0.5868244\",\n \"0.58660775\",\n \"0.58599275\",\n \"0.5842179\",\n \"0.5840974\",\n \"0.5839214\",\n \"0.58316386\",\n \"0.5831496\",\n \"0.58228415\",\n \"0.5801584\",\n \"0.57942504\",\n \"0.57933116\",\n \"0.5763543\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77441496"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14898,"cells":{"query":{"kind":"string","value":"Return the camera's software version."},"document":{"kind":"string","value":"def software_version(self) -> str:\n return self.data.get(Attribute.SOFTWARE_VERSION)"},"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 software_version(self) -> str:\n return self.camera_info[\"main_sw_version\"]","def hardware_version(self) -> str:\n return self.camera_info[\"main_hw_version\"]","def get_version(self):\r\n return self._arm.get_version()","def firmware_version(self):\n return self._get_system_status()[\"firmware\"]","def hardware_version(self):\n return self.data.get('hw_ver')","def firmware_version(self):\n return self.data.get('fw_ver')","def sw_version(self) -> str | None:\n return self.status.get(\"VERSION\")","def get_software_version(self):\n \n try:\n if self.product_info is None:\n self.product_info = self.connection.System.SystemInfo.\\\n get_product_information()\n return self.product_info['product_version']\n except:\n raise","def hw_version(self) -> str | None:\n return self.status.get(\"FIRMWARE\")","def get_hardware_revision():\n return _pigpio_command(_control, _PI_CMD_HWVER, 0, 0)","def fw_version(self):\n return self.capabilities.get(\"fw_ver\")","def firmware_version(self) -> str:\n return self._firmware_version","def get_version():\n return magpy.get_version()","def driver_version(self):\n data = fcntl.ioctl(self._fd, _EVIOCGVERSION, '\\x00\\x00\\x00\\x00')\n return struct.unpack(\"i\", data)[0]","def get_version():\n return about.get_version()","def firmware_version(self):\n return self._read(MX_FIRMWARE_VERSION)","def get_version():\n import RadioAbsTools\n return RadioAbsTools.__version__","def version(self):\n return \"%d.%d\" % (self._vmajor, self._vminor)","def get_firmware_version():\r\n return utils.run('crossystem fwid').stdout.strip()","def get_hardware_version(self):\n cmd = protocol.GET_HARDWARE_VERSION\n response = self.__send_and_receive(cmd)\n\n value = self.__gen_response_value(response)\n if value:\n self.hardware_version = value[0][1:]\n else:\n return False","def get_version():\n return 1","def version(self) -> str:\n data = \"none yet\"\n if self.STARTED:\n data = (\n self.about.get(\"Version\")\n or self.about.get(\"Installed Version\")\n or \"DEMO\"\n )\n data = data.replace(\"_\", \".\")\n return data","def firmware_version(self):\n buf = (ctypes.c_char * self.MAX_BUF_SIZE)()\n self._dll.JLINKARM_GetFirmwareString(buf, self.MAX_BUF_SIZE)\n return ctypes.string_at(buf).decode()","def fw_ver(self):\n return self._fw_ver","def get_release_version(self):\n return self.get_property(ADB.VERSION_RELEASE_PROPERTY)","def version():\n return uname().version","def version():\n return uname().version","def getFirmwareVersion(self, board=0):\n return self.callModule('admin', board, 0, 'getVersion')","def get_version(self):\n return self.version","def get_version():\n return '%d.%d.%d' % version_info","def version(self):\n done, data = self._request('GV')\n if done:\n return {\n 'firmware': data[0],\n 'protocol': data[1]\n }\n\n raise EvseError","def get_fw_version(self):\n summary = self.get_version_summary()\n pattern = '\\$.*? .*? .*? .*? .*? .*? .*? .*? (.*?) \\r\\n' \n fw_version = re.findall(pattern,summary).pop()\n return fw_version","def get_firmware_version(self):\n fw_version = {\n \"BIOS\": self._api_helper.read_txt_file(BIOS_VER_PATH),\n \"BMC\": self.__get_bmc_ver(),\n \"SWITCH_CPLD1\": self.__get_cpld_ver(SW_CPLD1_VER_PATH),\n \"SWITCH_CPLD2\": self.__get_cpld_ver(SW_CPLD2_VER_PATH),\n }.get(self.name, \"Unknown\")\n\n return fw_version","def get_version():\n click.echo(get_current_version_number())","async def get_version(self):\n\n # Display info message\n log.info(\"get_version\")\n\n # By default empty string\n version = \"\"\n\n # Run get version on the device\n output = await self.send_command(self.cmd_get_version)\n\n # Seek \"Version \" and \",\" to get the version in the returned output\n version = output.split(\"Version \")[1].split(\",\")[0]\n\n # Display info message\n log.info(f\"get_version: version: {version}\")\n\n # Return the version of the software of the device\n return version","def get_version(self):\n return 0","def getversion(): # 3\n res,resargs = _msk.Env.getversion()\n if res != 0:\n raise Error(rescode(res),\"\")\n _major_return_value,_minor_return_value,_build_return_value,_revision_return_value = resargs\n return _major_return_value,_minor_return_value,_build_return_value,_revision_return_value","def version(self):\n data = self._ftdi.spi_read(self.VERSION_ADDR, len=1, burst='fixed')\n return data[0] & self.VERSION_MASK","def version(self):\n return self.get_current_version()","def get_firmware_version(self):\n request_command = self.parser_invoker.get_firmware_version_command_bytes(self.sequence_id, self.product_id)\n response_command_content = self.connectObj.send_receive_command(request_command)\n return response_command_content","def get_version(self):\n return arbwave_version()","def get_product_version(self):\n return self.get_attr('product_version')","def get_firmware_version(self):\n cmd = protocol.GET_FIRMWARE_VERSION\n response = self.__send_and_receive(cmd)\n\n value = self.__gen_response_value(response)\n if value:\n self.firmware_version = value[0][1:]\n else:\n return False","def get_osversion(self):\n\t\treturn call_sdk_function('PrlFoundVmInfo_GetOSVersion', self.handle)","def version(self):\n a = re.search('(?<=_V)\\d{1,2}', self.fname)\n if a is None:\n return None\n else:\n return int(a.group())","def matlab_version():\n return str(matlab('version')).strip()","def hardware_version(self):\n version = self._dll.JLINKARM_GetHardwareVersion()\n major = version / 10000 % 100\n minor = version / 100 % 100\n return '%d.%02d' % (major, minor)","def version(self):\n\n if self.running() is True:\n return APIConsumer.get(\"/version\").content\n else:\n return None","def current_version(self):\n try:\n return self.release_set.order_by('-created')[0].version\n except IndexError:\n return \"0.0.0\"","def GetVersion(self) -> \"char const *\":\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMF2_GetVersion(self)","def software(s):\n try:\n import maya.mel as mel\n version = mel.eval(\"$tmp = getApplicationVersionAsFloat();\")\n return \"Maya, %s\" % version\n except ImportError:\n pass\n return \"Unknown software.\"","def get_version(self):\n return self.api_version","def version():\n\n print(VERSION_CODE)","def major_version(self):\n return self.unpack_dword(0x14)","def get_product_version(self):\n\t\treturn call_sdk_function('PrlSrvInfo_GetProductVersion', self.handle)","def get_version():\n return \"0.0.1 (prerelease prototype)\"","def get_revision(self):\n vers = self.send(\"?R\", recv=True)\n # Verify its a valid version\n # ? why was this commented out\n float(vers)\n # But return as string to avoid precision issues\n return vers","def model_version(self) -> str:\n return pulumi.get(self, \"model_version\")","def getFirmwareRevision(self): \n return self.firmware_revision","def getVersion(self):\n return self.get('Version', type=\"numeric\")","def current_image_version(self) -> str:\n return self._current_image_version","def version(self) -> str:\n self.__verify_repo_initialized()\n res = vcompat.get_repository_software_version_spec(self._env.branchenv)\n return str(res)","def src_get_version():\n return ffi.string(_lib.src_get_version()).decode()","def detect_version(self):\n\n version = self.scm_object.detect_version(self.args.__dict__).strip()\n logging.debug(\"VERSION(auto): %s\", version)\n return version","def version():\n cmd = \"{} -v\".format(_detect_os())\n out = __salt__[\"cmd.run\"](cmd).splitlines()\n ret = out[0].split(\": \")\n return ret[1]","def version():\n return _nfc.version()","def get_version():\n return \"4.{}\".format(__version__)","def get_version_string():\n\n version_string = get_version()\n if not version_string:\n version_string = \"unknown\"\n\n return \"ImageSplit version \" + version_string","def getversion(self):\n return self.__version","def player_version(self):\n # type: () -> string_types\n return self._player_version","def version(self):\n return self._get(\"version\")","def get_version():\r\n return __version__","def GetVersion(self) -> \"char const *\":\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMF3_GetVersion(self)","def get_version(cls) -> str:\n if not cls.is_available():\n return 'None'\n else:\n import pkg_resources\n try:\n return pkg_resources.get_distribution('ncnn').version\n except Exception:\n return 'None'","def get_version():\n vers = [\"%(major)i.%(minor)i\" % __version_info__, ]\n\n if __version_info__['micro']:\n vers.append(\".%(micro)i\" % __version_info__)\n if __version_info__['releaselevel'] != 'final':\n vers.append('%(releaselevel)s' % __version_info__)\n return ''.join(vers)","def get_version(self):\n pass","def version(self):\n\n return self.manifest[\"version\"]","def get_version(self) -> str:\n return versioning.get_version()","def get_version():\n major=c_int_t(0)\n minor=c_int_t(0)\n patch=c_int_t(0)\n safe_call(backend.get().af_get_version(c_pointer(major), c_pointer(minor), c_pointer(patch)))\n return major.value,minor.value,patch.value","def version():\n print \"Cvlib Version: \" + str(__version__)\n print \"OpenCV Version: \" + str(__opencv__)\n print \"Numpy Version: \" + str(__npversion__)\n print \"Matplotlib Ver: \" + str(__matplotlibver__)\n print \"Python Version: \" + str(__sysver__)","def current_version(self):\n if self.current_tag:\n version = self.current_tag.lstrip('v')\n else:\n version = None\n\n if version and not version_is_valid(version):\n version = None\n\n return version","def getVersion():\n try:\n fh=open(version_py, 'r')\n version=fh.read().strip().split('=')[-1].replace(\"'\",'').lstrip()\n fh.close()\n except:\n return None\n\n return version","def version(self) -> Optional[str]:\n return pulumi.get(self, \"version\")","def version(self) -> Optional[str]:\n return pulumi.get(self, \"version\")","def version(self) -> Optional[str]:\n return pulumi.get(self, \"version\")","def version(self) -> Optional[str]:\n return pulumi.get(self, \"version\")","def version(self) -> Optional[str]:\n return pulumi.get(self, \"version\")","def engine_version(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"engine_version\")","def engine_version(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"engine_version\")","def engine_version(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"engine_version\")","def get_version(self):\n return self._version","def get_version(self):\n return self._version","def GetVersion(self) -> \"char const *\":\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMD2_GetVersion(self)","def get_version(self):\n return self.cur_config['version']['name']","def engine_version(self) -> str:\n return pulumi.get(self, \"engine_version\")","def version(self) -> str:\n return utils._auxiliary.get_current_sdk_version()","def get_version(self, params):\n return self.version","def major_version(self) -> str:\n return pulumi.get(self, \"major_version\")","def version(self):\n _, body = self.request('/', 'GET')\n return body.get('version', None)","def version(self):\n ver = c_uint()\n ckresult(_dll.FMOD_System_GetVersion(self._ptr, byref(ver)))\n return ver.value"],"string":"[\n \"def software_version(self) -> str:\\n return self.camera_info[\\\"main_sw_version\\\"]\",\n \"def hardware_version(self) -> str:\\n return self.camera_info[\\\"main_hw_version\\\"]\",\n \"def get_version(self):\\r\\n return self._arm.get_version()\",\n \"def firmware_version(self):\\n return self._get_system_status()[\\\"firmware\\\"]\",\n \"def hardware_version(self):\\n return self.data.get('hw_ver')\",\n \"def firmware_version(self):\\n return self.data.get('fw_ver')\",\n \"def sw_version(self) -> str | None:\\n return self.status.get(\\\"VERSION\\\")\",\n \"def get_software_version(self):\\n \\n try:\\n if self.product_info is None:\\n self.product_info = self.connection.System.SystemInfo.\\\\\\n get_product_information()\\n return self.product_info['product_version']\\n except:\\n raise\",\n \"def hw_version(self) -> str | None:\\n return self.status.get(\\\"FIRMWARE\\\")\",\n \"def get_hardware_revision():\\n return _pigpio_command(_control, _PI_CMD_HWVER, 0, 0)\",\n \"def fw_version(self):\\n return self.capabilities.get(\\\"fw_ver\\\")\",\n \"def firmware_version(self) -> str:\\n return self._firmware_version\",\n \"def get_version():\\n return magpy.get_version()\",\n \"def driver_version(self):\\n data = fcntl.ioctl(self._fd, _EVIOCGVERSION, '\\\\x00\\\\x00\\\\x00\\\\x00')\\n return struct.unpack(\\\"i\\\", data)[0]\",\n \"def get_version():\\n return about.get_version()\",\n \"def firmware_version(self):\\n return self._read(MX_FIRMWARE_VERSION)\",\n \"def get_version():\\n import RadioAbsTools\\n return RadioAbsTools.__version__\",\n \"def version(self):\\n return \\\"%d.%d\\\" % (self._vmajor, self._vminor)\",\n \"def get_firmware_version():\\r\\n return utils.run('crossystem fwid').stdout.strip()\",\n \"def get_hardware_version(self):\\n cmd = protocol.GET_HARDWARE_VERSION\\n response = self.__send_and_receive(cmd)\\n\\n value = self.__gen_response_value(response)\\n if value:\\n self.hardware_version = value[0][1:]\\n else:\\n return False\",\n \"def get_version():\\n return 1\",\n \"def version(self) -> str:\\n data = \\\"none yet\\\"\\n if self.STARTED:\\n data = (\\n self.about.get(\\\"Version\\\")\\n or self.about.get(\\\"Installed Version\\\")\\n or \\\"DEMO\\\"\\n )\\n data = data.replace(\\\"_\\\", \\\".\\\")\\n return data\",\n \"def firmware_version(self):\\n buf = (ctypes.c_char * self.MAX_BUF_SIZE)()\\n self._dll.JLINKARM_GetFirmwareString(buf, self.MAX_BUF_SIZE)\\n return ctypes.string_at(buf).decode()\",\n \"def fw_ver(self):\\n return self._fw_ver\",\n \"def get_release_version(self):\\n return self.get_property(ADB.VERSION_RELEASE_PROPERTY)\",\n \"def version():\\n return uname().version\",\n \"def version():\\n return uname().version\",\n \"def getFirmwareVersion(self, board=0):\\n return self.callModule('admin', board, 0, 'getVersion')\",\n \"def get_version(self):\\n return self.version\",\n \"def get_version():\\n return '%d.%d.%d' % version_info\",\n \"def version(self):\\n done, data = self._request('GV')\\n if done:\\n return {\\n 'firmware': data[0],\\n 'protocol': data[1]\\n }\\n\\n raise EvseError\",\n \"def get_fw_version(self):\\n summary = self.get_version_summary()\\n pattern = '\\\\$.*? .*? .*? .*? .*? .*? .*? .*? (.*?) \\\\r\\\\n' \\n fw_version = re.findall(pattern,summary).pop()\\n return fw_version\",\n \"def get_firmware_version(self):\\n fw_version = {\\n \\\"BIOS\\\": self._api_helper.read_txt_file(BIOS_VER_PATH),\\n \\\"BMC\\\": self.__get_bmc_ver(),\\n \\\"SWITCH_CPLD1\\\": self.__get_cpld_ver(SW_CPLD1_VER_PATH),\\n \\\"SWITCH_CPLD2\\\": self.__get_cpld_ver(SW_CPLD2_VER_PATH),\\n }.get(self.name, \\\"Unknown\\\")\\n\\n return fw_version\",\n \"def get_version():\\n click.echo(get_current_version_number())\",\n \"async def get_version(self):\\n\\n # Display info message\\n log.info(\\\"get_version\\\")\\n\\n # By default empty string\\n version = \\\"\\\"\\n\\n # Run get version on the device\\n output = await self.send_command(self.cmd_get_version)\\n\\n # Seek \\\"Version \\\" and \\\",\\\" to get the version in the returned output\\n version = output.split(\\\"Version \\\")[1].split(\\\",\\\")[0]\\n\\n # Display info message\\n log.info(f\\\"get_version: version: {version}\\\")\\n\\n # Return the version of the software of the device\\n return version\",\n \"def get_version(self):\\n return 0\",\n \"def getversion(): # 3\\n res,resargs = _msk.Env.getversion()\\n if res != 0:\\n raise Error(rescode(res),\\\"\\\")\\n _major_return_value,_minor_return_value,_build_return_value,_revision_return_value = resargs\\n return _major_return_value,_minor_return_value,_build_return_value,_revision_return_value\",\n \"def version(self):\\n data = self._ftdi.spi_read(self.VERSION_ADDR, len=1, burst='fixed')\\n return data[0] & self.VERSION_MASK\",\n \"def version(self):\\n return self.get_current_version()\",\n \"def get_firmware_version(self):\\n request_command = self.parser_invoker.get_firmware_version_command_bytes(self.sequence_id, self.product_id)\\n response_command_content = self.connectObj.send_receive_command(request_command)\\n return response_command_content\",\n \"def get_version(self):\\n return arbwave_version()\",\n \"def get_product_version(self):\\n return self.get_attr('product_version')\",\n \"def get_firmware_version(self):\\n cmd = protocol.GET_FIRMWARE_VERSION\\n response = self.__send_and_receive(cmd)\\n\\n value = self.__gen_response_value(response)\\n if value:\\n self.firmware_version = value[0][1:]\\n else:\\n return False\",\n \"def get_osversion(self):\\n\\t\\treturn call_sdk_function('PrlFoundVmInfo_GetOSVersion', self.handle)\",\n \"def version(self):\\n a = re.search('(?<=_V)\\\\d{1,2}', self.fname)\\n if a is None:\\n return None\\n else:\\n return int(a.group())\",\n \"def matlab_version():\\n return str(matlab('version')).strip()\",\n \"def hardware_version(self):\\n version = self._dll.JLINKARM_GetHardwareVersion()\\n major = version / 10000 % 100\\n minor = version / 100 % 100\\n return '%d.%02d' % (major, minor)\",\n \"def version(self):\\n\\n if self.running() is True:\\n return APIConsumer.get(\\\"/version\\\").content\\n else:\\n return None\",\n \"def current_version(self):\\n try:\\n return self.release_set.order_by('-created')[0].version\\n except IndexError:\\n return \\\"0.0.0\\\"\",\n \"def GetVersion(self) -> \\\"char const *\\\":\\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMF2_GetVersion(self)\",\n \"def software(s):\\n try:\\n import maya.mel as mel\\n version = mel.eval(\\\"$tmp = getApplicationVersionAsFloat();\\\")\\n return \\\"Maya, %s\\\" % version\\n except ImportError:\\n pass\\n return \\\"Unknown software.\\\"\",\n \"def get_version(self):\\n return self.api_version\",\n \"def version():\\n\\n print(VERSION_CODE)\",\n \"def major_version(self):\\n return self.unpack_dword(0x14)\",\n \"def get_product_version(self):\\n\\t\\treturn call_sdk_function('PrlSrvInfo_GetProductVersion', self.handle)\",\n \"def get_version():\\n return \\\"0.0.1 (prerelease prototype)\\\"\",\n \"def get_revision(self):\\n vers = self.send(\\\"?R\\\", recv=True)\\n # Verify its a valid version\\n # ? why was this commented out\\n float(vers)\\n # But return as string to avoid precision issues\\n return vers\",\n \"def model_version(self) -> str:\\n return pulumi.get(self, \\\"model_version\\\")\",\n \"def getFirmwareRevision(self): \\n return self.firmware_revision\",\n \"def getVersion(self):\\n return self.get('Version', type=\\\"numeric\\\")\",\n \"def current_image_version(self) -> str:\\n return self._current_image_version\",\n \"def version(self) -> str:\\n self.__verify_repo_initialized()\\n res = vcompat.get_repository_software_version_spec(self._env.branchenv)\\n return str(res)\",\n \"def src_get_version():\\n return ffi.string(_lib.src_get_version()).decode()\",\n \"def detect_version(self):\\n\\n version = self.scm_object.detect_version(self.args.__dict__).strip()\\n logging.debug(\\\"VERSION(auto): %s\\\", version)\\n return version\",\n \"def version():\\n cmd = \\\"{} -v\\\".format(_detect_os())\\n out = __salt__[\\\"cmd.run\\\"](cmd).splitlines()\\n ret = out[0].split(\\\": \\\")\\n return ret[1]\",\n \"def version():\\n return _nfc.version()\",\n \"def get_version():\\n return \\\"4.{}\\\".format(__version__)\",\n \"def get_version_string():\\n\\n version_string = get_version()\\n if not version_string:\\n version_string = \\\"unknown\\\"\\n\\n return \\\"ImageSplit version \\\" + version_string\",\n \"def getversion(self):\\n return self.__version\",\n \"def player_version(self):\\n # type: () -> string_types\\n return self._player_version\",\n \"def version(self):\\n return self._get(\\\"version\\\")\",\n \"def get_version():\\r\\n return __version__\",\n \"def GetVersion(self) -> \\\"char const *\\\":\\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMF3_GetVersion(self)\",\n \"def get_version(cls) -> str:\\n if not cls.is_available():\\n return 'None'\\n else:\\n import pkg_resources\\n try:\\n return pkg_resources.get_distribution('ncnn').version\\n except Exception:\\n return 'None'\",\n \"def get_version():\\n vers = [\\\"%(major)i.%(minor)i\\\" % __version_info__, ]\\n\\n if __version_info__['micro']:\\n vers.append(\\\".%(micro)i\\\" % __version_info__)\\n if __version_info__['releaselevel'] != 'final':\\n vers.append('%(releaselevel)s' % __version_info__)\\n return ''.join(vers)\",\n \"def get_version(self):\\n pass\",\n \"def version(self):\\n\\n return self.manifest[\\\"version\\\"]\",\n \"def get_version(self) -> str:\\n return versioning.get_version()\",\n \"def get_version():\\n major=c_int_t(0)\\n minor=c_int_t(0)\\n patch=c_int_t(0)\\n safe_call(backend.get().af_get_version(c_pointer(major), c_pointer(minor), c_pointer(patch)))\\n return major.value,minor.value,patch.value\",\n \"def version():\\n print \\\"Cvlib Version: \\\" + str(__version__)\\n print \\\"OpenCV Version: \\\" + str(__opencv__)\\n print \\\"Numpy Version: \\\" + str(__npversion__)\\n print \\\"Matplotlib Ver: \\\" + str(__matplotlibver__)\\n print \\\"Python Version: \\\" + str(__sysver__)\",\n \"def current_version(self):\\n if self.current_tag:\\n version = self.current_tag.lstrip('v')\\n else:\\n version = None\\n\\n if version and not version_is_valid(version):\\n version = None\\n\\n return version\",\n \"def getVersion():\\n try:\\n fh=open(version_py, 'r')\\n version=fh.read().strip().split('=')[-1].replace(\\\"'\\\",'').lstrip()\\n fh.close()\\n except:\\n return None\\n\\n return version\",\n \"def version(self) -> Optional[str]:\\n return pulumi.get(self, \\\"version\\\")\",\n \"def version(self) -> Optional[str]:\\n return pulumi.get(self, \\\"version\\\")\",\n \"def version(self) -> Optional[str]:\\n return pulumi.get(self, \\\"version\\\")\",\n \"def version(self) -> Optional[str]:\\n return pulumi.get(self, \\\"version\\\")\",\n \"def version(self) -> Optional[str]:\\n return pulumi.get(self, \\\"version\\\")\",\n \"def engine_version(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"engine_version\\\")\",\n \"def engine_version(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"engine_version\\\")\",\n \"def engine_version(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"engine_version\\\")\",\n \"def get_version(self):\\n return self._version\",\n \"def get_version(self):\\n return self._version\",\n \"def GetVersion(self) -> \\\"char const *\\\":\\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMD2_GetVersion(self)\",\n \"def get_version(self):\\n return self.cur_config['version']['name']\",\n \"def engine_version(self) -> str:\\n return pulumi.get(self, \\\"engine_version\\\")\",\n \"def version(self) -> str:\\n return utils._auxiliary.get_current_sdk_version()\",\n \"def get_version(self, params):\\n return self.version\",\n \"def major_version(self) -> str:\\n return pulumi.get(self, \\\"major_version\\\")\",\n \"def version(self):\\n _, body = self.request('/', 'GET')\\n return body.get('version', None)\",\n \"def version(self):\\n ver = c_uint()\\n ckresult(_dll.FMOD_System_GetVersion(self._ptr, byref(ver)))\\n return ver.value\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.89519215","0.83684665","0.74867046","0.73334736","0.72057974","0.71801555","0.7148547","0.71403116","0.71381164","0.7101077","0.7082621","0.7062264","0.6997098","0.69791687","0.69379365","0.69282806","0.69030863","0.6860852","0.6859731","0.68596333","0.68567073","0.68548465","0.68113714","0.6757605","0.67483085","0.6738567","0.6738567","0.6698447","0.6674243","0.66732514","0.66699225","0.66678256","0.66634226","0.6662337","0.6655872","0.6649036","0.6647194","0.6641037","0.66156226","0.6601654","0.6588301","0.65754265","0.65643513","0.6561732","0.65564597","0.65496904","0.65482485","0.654264","0.65394133","0.65338534","0.6530649","0.65241975","0.65232825","0.6520312","0.65190053","0.6512815","0.6501742","0.64896536","0.6484806","0.64809275","0.64777386","0.64740926","0.6472917","0.64695376","0.6469507","0.64668083","0.64561695","0.6455397","0.64538425","0.64512086","0.64473295","0.644699","0.64469665","0.6437861","0.64352816","0.64333177","0.64236933","0.6410544","0.64018583","0.6397618","0.6394324","0.63895726","0.6386093","0.6386093","0.6386093","0.6386093","0.6386093","0.6385692","0.6385692","0.6385692","0.63825476","0.63825476","0.6381102","0.63682467","0.6352776","0.63363224","0.63334286","0.6330519","0.632344","0.63234305"],"string":"[\n \"0.89519215\",\n \"0.83684665\",\n \"0.74867046\",\n \"0.73334736\",\n \"0.72057974\",\n \"0.71801555\",\n \"0.7148547\",\n \"0.71403116\",\n \"0.71381164\",\n \"0.7101077\",\n \"0.7082621\",\n \"0.7062264\",\n \"0.6997098\",\n \"0.69791687\",\n \"0.69379365\",\n \"0.69282806\",\n \"0.69030863\",\n \"0.6860852\",\n \"0.6859731\",\n \"0.68596333\",\n \"0.68567073\",\n \"0.68548465\",\n \"0.68113714\",\n \"0.6757605\",\n \"0.67483085\",\n \"0.6738567\",\n \"0.6738567\",\n \"0.6698447\",\n \"0.6674243\",\n \"0.66732514\",\n \"0.66699225\",\n \"0.66678256\",\n \"0.66634226\",\n \"0.6662337\",\n \"0.6655872\",\n \"0.6649036\",\n \"0.6647194\",\n \"0.6641037\",\n \"0.66156226\",\n \"0.6601654\",\n \"0.6588301\",\n \"0.65754265\",\n \"0.65643513\",\n \"0.6561732\",\n \"0.65564597\",\n \"0.65496904\",\n \"0.65482485\",\n \"0.654264\",\n \"0.65394133\",\n \"0.65338534\",\n \"0.6530649\",\n \"0.65241975\",\n \"0.65232825\",\n \"0.6520312\",\n \"0.65190053\",\n \"0.6512815\",\n \"0.6501742\",\n \"0.64896536\",\n \"0.6484806\",\n \"0.64809275\",\n \"0.64777386\",\n \"0.64740926\",\n \"0.6472917\",\n \"0.64695376\",\n \"0.6469507\",\n \"0.64668083\",\n \"0.64561695\",\n \"0.6455397\",\n \"0.64538425\",\n \"0.64512086\",\n \"0.64473295\",\n \"0.644699\",\n \"0.64469665\",\n \"0.6437861\",\n \"0.64352816\",\n \"0.64333177\",\n \"0.64236933\",\n \"0.6410544\",\n \"0.64018583\",\n \"0.6397618\",\n \"0.6394324\",\n \"0.63895726\",\n \"0.6386093\",\n \"0.6386093\",\n \"0.6386093\",\n \"0.6386093\",\n \"0.6386093\",\n \"0.6385692\",\n \"0.6385692\",\n \"0.6385692\",\n \"0.63825476\",\n \"0.63825476\",\n \"0.6381102\",\n \"0.63682467\",\n \"0.6352776\",\n \"0.63363224\",\n \"0.63334286\",\n \"0.6330519\",\n \"0.632344\",\n \"0.63234305\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7609568"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":14899,"cells":{"query":{"kind":"string","value":"Return True if capture clip on motion is active."},"document":{"kind":"string","value":"def capture_clip_on_motion(self) -> bool:\n return self.data[Attribute.CAPTURE_CLIP_ON_MOTION]"},"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 capture_is_active(self):\n return self.um in self._streams","def can_activate(self):\n if self.video_library.get_number_of_video_clips() == 0:\n return False\n else:\n return True","def motion_detection_enabled(self):\n return self._motion_status","def is_active(self) -> bool:\n return self.map.active_cam == self.map.cameras.index(self) + 1","def is_StartCapture_allowed(self):\n handler = self.get_command_object(\"StartCapture\")\n return handler.check_allowed()","def is_playing(self):\n return self.process is not None","def is_screen_on(self):\n out = self.adb.get_window_policy_info()\n pattern = re.compile('mScreenOnFully=(true|false)')\n return pattern.search(str(out)).group(1)","def get_active(self):\n if hasattr(self, 'canvas'):\n return True\n else:\n return False","def require_motion(self) -> bool:\n return self._require_motion","def is_on(self):\n camera = self.coordinator.data[self._camera_id]\n if self._switch_type == \"record_motion\":\n enabled = True if camera[\"recording_mode\"] == TYPE_RECORD_MOTION else False\n elif self._switch_type == \"record_always\":\n enabled = True if camera[\"recording_mode\"] == TYPE_RECORD_ALLWAYS else False\n else:\n enabled = True if camera[\"ir_mode\"] == self._ir_on_cmd else False\n return enabled","def isActive(self):\n self._acquire_lock()\n returned = True\n try:\n if len(self.existing_frames) == 0 :\n returned = False\n finally:\n self._release_lock()\n return returned","def captured(self):\n return self.game.enemyTeam.flag.carrier != None","def captured(self):\n return self.game.enemyTeam.flag.carrier != None","def captured(self):\n return self.commander.game.enemyTeam.flag.carrier != None","def captured(self):\n return self.commander.game.enemyTeam.flag.carrier != None","def camera_set(self) -> bool:\n if self.camera is None: # pragma: no cover\n return False\n return self.camera.is_set","def hasMultiPassEffects(self):\r\n cls = mxs.classOf(self._nativePointer)\r\n if cls in (mxs.VRayPhysicalCamera, mxs.Physical):\r\n return self._nativePointer.use_DOF\r\n elif mxs.isProperty(self._nativePointer, 'mpassEnabled'):\r\n return self._nativePointer.mpassEnabled\r\n return False","def _isInIdle(self):\r\n if core.FW_conf['blackbox'].isVideoRecorderAvailable() and core.FW_conf['blackbox'].videoClient.GetCurrentState() == 'idle':\r\n self.inIdle = True\r\n return True\r\n else:\r\n return False","def is_capturing(self):\r\n self.priority += self.captures*10","def is_motion(self, channel=None):\n return bool(self.getBinaryData(\"MOTION\", channel))","def is_motion(self, channel=None):\n return bool(self.getBinaryData(\"MOTION\", channel))","def detectMotion():\n global MotionDetected\n MotionDetected = False\n return MotionDetected","def is_on(self) -> bool:\n return self._client.get_circ_pump()","def is_active(self):\n with self._lock:\n return self._robot is not None","def is_active(self):\n if self.steps > STEPS_MAX or not self.targets[0]:\n return False\n return True","def detector_active(self) -> bool:\n\t\treturn self._raw_result['data']['detectorActive']","def can_play_on_all_active(self):\n if self.last_move is None:\n return True\n x, y = self.last_move[-2:]\n if self.boards[x][y].state != State.IN_PROGRESS:\n return True\n return False","def is_StopCapture_allowed(self):\n handler = self.get_command_object(\"StopCapture\")\n return handler.check_allowed()","def checkCamera(self):\n #how to check if cam exits\n #https://stackoverflow.com/questions/48049886/how-to-correctly-check-if-a-camera-is-available\n if \"has_cam\" in self.store.keys():\n return self.store[\"has_cam\"]\n\n cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)\n\n if cap is None or not cap.isOpened():\n return False\n #Close the cam\n cap.release()\n cv2.destroyAllWindows()\n return True","def detect(frame: numpy.ndarray) -> bool:\n color = frame[:20, 1100:1150].mean(axis=(0, 1))\n return numpy.linalg.norm(color - BG_COLOR) < 5","def is_active(self):\n return self.state == self.States.playing","def enable_motion_detection(self):\n ret = self._nvr.set_camera_recording(self._uuid, \"motion\")\n if not ret:\n return\n\n self._motion_status = \"motion\"\n self._isrecording = True\n _LOGGER.debug(\"Motion Detection Enabled for Camera: %s\", self._name)","def is_moving(self):\n return self.gripper_io.get_signal_value(\"is_moving\")","def is_active(self) -> bool:\n return self._stream.active","def is_active(self) -> bool:\r\n return self.active","def Active(self):\n return self.NMove > 0","def motionBlur(self):\r\n if mxs.classOf(self._nativePointer) == mxs.VRayPhysicalCamera:\r\n return self._nativePointer.use_moBlur\r\n elif mxs.classOf(self._nativePointer) == mxs.Physical:\r\n return self._nativePointer.motion_blur_enabled\r\n else:\r\n return False","def isRecording(self):\n if not self.proxy:\n self.proxy = self.session.service(\"ALVideoRecorder\")\n return self.proxy.isRecording()","def is_active(self):\n return self.stream.is_active()","def is_playing(self):\n return self.connected_channel is not None and self.current is not None","def passive_game(self):\n passive_game = False\n if len(self.moves) >= constant.MAX_MOVES_WITHOUT_CAPTURE:\n passive_game = True\n for move in range(constant.MAX_MOVES_WITHOUT_CAPTURE):\n if len(self.moves[-move][2]) != 0:\n passive_game = False\n break\n\n return passive_game","def is_recording(self):\n return self._isrecording","def is_playing(self):\n command_output = self.run_command('is_playing')[0]\n return True if command_output == '1' else False","def is_on(self):\n if self._switch_type == \"record_motion\":\n return self._camera_data[\"recording_mode\"] == TYPE_RECORD_MOTION\n elif self._switch_type == \"record_always\":\n return self._camera_data[\"recording_mode\"] == TYPE_RECORD_ALWAYS\n elif self._switch_type == \"record_smart\":\n return self._camera_data[\"recording_mode\"] == TYPE_RECORD_SMARTDETECT\n elif self._switch_type == \"ir_mode\":\n return self._camera_data[\"ir_mode\"] == self._ir_on_cmd\n elif self._switch_type == \"hdr_mode\":\n return self._camera_data[\"hdr_mode\"] is True\n elif self._switch_type == \"high_fps\":\n return self._camera_data[\"video_mode\"] == TYPE_HIGH_FPS_ON\n else:\n return self._camera_data[\"status_light\"] == \"True\"","def is_active(self) -> bool:\n return self.__is_active","def is_active(self) -> bool:","def is_active(self):\n now = self.sim.now\n return (now < self.stop) and (self._number < self.max_length) \\\n and (now >= self.start)","def _isInCamera(self, pos):\n return self._isInScreen(self._posToScreenCoords(pos))","def is_active():\n return True","def is_snap_enabled(self) -> bool:\r\n ...","def is_on(self):\n return self._brightness > 0 or self._white_value > 0","def is_on(self):\n return self._brightness != 0","def is_active(self):\n\t\tself.stream.is_active()","def is_active(self) -> bool:\n return self._is_active","def is_recording(self):\n return True if self._device.device_data[self._uuid]['streaming_state'] == \\\n 'streaming-enabled' else False","def isGrabando(self):\n return self.grabando","def _media_playback_trackable(self) -> bool:\n if (\n self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.Duration\n is None\n ):\n return False\n\n return (\n self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.Duration > 0\n )","def is_playing_dialtone(self) -> bool:","def is_active(self):\n with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True):\n return self._action('is-active').succeeded","def is_calibrated(self):\n return self.gripper_io.get_signal_value(\"is_calibrated\")","def hasCurrentFrame(self):\n if self.currentFrame == []:\n return False\n return True","def isPlaying(self):\n return self.getChannel().get_busy()","def check_mode(self):\n if self.proximity.check_press():\n self.cycle_mode()\n return self.mode","def is_active(self):\n return bool(\n self._grpc_port is not None and\n self._event_multiplexer and\n self._event_multiplexer.PluginRunToTagToContent(\n constants.DEBUGGER_PLUGIN_NAME))","def with_allows_camera(self):\n return self.with_allowed_capture_methods(CAMERA)","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def is_active(self):\n return True","def enemyCaptured(self):\n return self.game.team.flag.carrier != None","def have_circ_pump(self):\n return bool(self.circ_pump)","def is_on(self) -> bool:\n return self._zone.data[\"mode\"] == \"override\" and self._zone.data[\"setpoint\"]","def CaptureMode(self):\n if self.force_auto_sync:\n self.get('CaptureMode')\n return self._CaptureMode","def is_smelling(self,conc_array):\n if conc_array[int(self.x)][int(self.y)]>self.threshold:\n self.smell_timer = self.Timer(self.T,self.lamda)\n #Nav mode three and four need to know whether the moth is smelling\n #at a specific moment, for that reason they use Tfirst.\n self.Tfirst = self.T\n self.odor = True #this datum will be useful in the graphical functions\n return True\n elif self.turned_on:\n self.odor = False\n if self.smell_timer.is_running(self.T):\n return True #note - even though the there is no detection, the navigator stay in nav mode.\n else:\n self.odor = False\n return False","def is_on(self):\n return self._light_on","def get_allow_approx_motion(self):\r\n return self._arm.get_allow_approx_motion()","def is_on(self):\n return self.sec_start is not None and self.sec_stop is None","def is_moving(self):\n is_moving = self.get_raw_status() & self.STATUS_MOVING\n return bool(is_moving)","def active(self) -> bool:\n return bool(self.log)","def active(self) -> bool:\n return self._active","def is_active(self):\r\n return self.active","def is_active(self):\r\n return True","def is_on(self) -> bool:\n return self._device.is_on","def poll(cls, context):\r\n return context.object.animation_data.action is not None","def is_active(self):\n return self.active"],"string":"[\n \"def capture_is_active(self):\\n return self.um in self._streams\",\n \"def can_activate(self):\\n if self.video_library.get_number_of_video_clips() == 0:\\n return False\\n else:\\n return True\",\n \"def motion_detection_enabled(self):\\n return self._motion_status\",\n \"def is_active(self) -> bool:\\n return self.map.active_cam == self.map.cameras.index(self) + 1\",\n \"def is_StartCapture_allowed(self):\\n handler = self.get_command_object(\\\"StartCapture\\\")\\n return handler.check_allowed()\",\n \"def is_playing(self):\\n return self.process is not None\",\n \"def is_screen_on(self):\\n out = self.adb.get_window_policy_info()\\n pattern = re.compile('mScreenOnFully=(true|false)')\\n return pattern.search(str(out)).group(1)\",\n \"def get_active(self):\\n if hasattr(self, 'canvas'):\\n return True\\n else:\\n return False\",\n \"def require_motion(self) -> bool:\\n return self._require_motion\",\n \"def is_on(self):\\n camera = self.coordinator.data[self._camera_id]\\n if self._switch_type == \\\"record_motion\\\":\\n enabled = True if camera[\\\"recording_mode\\\"] == TYPE_RECORD_MOTION else False\\n elif self._switch_type == \\\"record_always\\\":\\n enabled = True if camera[\\\"recording_mode\\\"] == TYPE_RECORD_ALLWAYS else False\\n else:\\n enabled = True if camera[\\\"ir_mode\\\"] == self._ir_on_cmd else False\\n return enabled\",\n \"def isActive(self):\\n self._acquire_lock()\\n returned = True\\n try:\\n if len(self.existing_frames) == 0 :\\n returned = False\\n finally:\\n self._release_lock()\\n return returned\",\n \"def captured(self):\\n return self.game.enemyTeam.flag.carrier != None\",\n \"def captured(self):\\n return self.game.enemyTeam.flag.carrier != None\",\n \"def captured(self):\\n return self.commander.game.enemyTeam.flag.carrier != None\",\n \"def captured(self):\\n return self.commander.game.enemyTeam.flag.carrier != None\",\n \"def camera_set(self) -> bool:\\n if self.camera is None: # pragma: no cover\\n return False\\n return self.camera.is_set\",\n \"def hasMultiPassEffects(self):\\r\\n cls = mxs.classOf(self._nativePointer)\\r\\n if cls in (mxs.VRayPhysicalCamera, mxs.Physical):\\r\\n return self._nativePointer.use_DOF\\r\\n elif mxs.isProperty(self._nativePointer, 'mpassEnabled'):\\r\\n return self._nativePointer.mpassEnabled\\r\\n return False\",\n \"def _isInIdle(self):\\r\\n if core.FW_conf['blackbox'].isVideoRecorderAvailable() and core.FW_conf['blackbox'].videoClient.GetCurrentState() == 'idle':\\r\\n self.inIdle = True\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def is_capturing(self):\\r\\n self.priority += self.captures*10\",\n \"def is_motion(self, channel=None):\\n return bool(self.getBinaryData(\\\"MOTION\\\", channel))\",\n \"def is_motion(self, channel=None):\\n return bool(self.getBinaryData(\\\"MOTION\\\", channel))\",\n \"def detectMotion():\\n global MotionDetected\\n MotionDetected = False\\n return MotionDetected\",\n \"def is_on(self) -> bool:\\n return self._client.get_circ_pump()\",\n \"def is_active(self):\\n with self._lock:\\n return self._robot is not None\",\n \"def is_active(self):\\n if self.steps > STEPS_MAX or not self.targets[0]:\\n return False\\n return True\",\n \"def detector_active(self) -> bool:\\n\\t\\treturn self._raw_result['data']['detectorActive']\",\n \"def can_play_on_all_active(self):\\n if self.last_move is None:\\n return True\\n x, y = self.last_move[-2:]\\n if self.boards[x][y].state != State.IN_PROGRESS:\\n return True\\n return False\",\n \"def is_StopCapture_allowed(self):\\n handler = self.get_command_object(\\\"StopCapture\\\")\\n return handler.check_allowed()\",\n \"def checkCamera(self):\\n #how to check if cam exits\\n #https://stackoverflow.com/questions/48049886/how-to-correctly-check-if-a-camera-is-available\\n if \\\"has_cam\\\" in self.store.keys():\\n return self.store[\\\"has_cam\\\"]\\n\\n cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)\\n\\n if cap is None or not cap.isOpened():\\n return False\\n #Close the cam\\n cap.release()\\n cv2.destroyAllWindows()\\n return True\",\n \"def detect(frame: numpy.ndarray) -> bool:\\n color = frame[:20, 1100:1150].mean(axis=(0, 1))\\n return numpy.linalg.norm(color - BG_COLOR) < 5\",\n \"def is_active(self):\\n return self.state == self.States.playing\",\n \"def enable_motion_detection(self):\\n ret = self._nvr.set_camera_recording(self._uuid, \\\"motion\\\")\\n if not ret:\\n return\\n\\n self._motion_status = \\\"motion\\\"\\n self._isrecording = True\\n _LOGGER.debug(\\\"Motion Detection Enabled for Camera: %s\\\", self._name)\",\n \"def is_moving(self):\\n return self.gripper_io.get_signal_value(\\\"is_moving\\\")\",\n \"def is_active(self) -> bool:\\n return self._stream.active\",\n \"def is_active(self) -> bool:\\r\\n return self.active\",\n \"def Active(self):\\n return self.NMove > 0\",\n \"def motionBlur(self):\\r\\n if mxs.classOf(self._nativePointer) == mxs.VRayPhysicalCamera:\\r\\n return self._nativePointer.use_moBlur\\r\\n elif mxs.classOf(self._nativePointer) == mxs.Physical:\\r\\n return self._nativePointer.motion_blur_enabled\\r\\n else:\\r\\n return False\",\n \"def isRecording(self):\\n if not self.proxy:\\n self.proxy = self.session.service(\\\"ALVideoRecorder\\\")\\n return self.proxy.isRecording()\",\n \"def is_active(self):\\n return self.stream.is_active()\",\n \"def is_playing(self):\\n return self.connected_channel is not None and self.current is not None\",\n \"def passive_game(self):\\n passive_game = False\\n if len(self.moves) >= constant.MAX_MOVES_WITHOUT_CAPTURE:\\n passive_game = True\\n for move in range(constant.MAX_MOVES_WITHOUT_CAPTURE):\\n if len(self.moves[-move][2]) != 0:\\n passive_game = False\\n break\\n\\n return passive_game\",\n \"def is_recording(self):\\n return self._isrecording\",\n \"def is_playing(self):\\n command_output = self.run_command('is_playing')[0]\\n return True if command_output == '1' else False\",\n \"def is_on(self):\\n if self._switch_type == \\\"record_motion\\\":\\n return self._camera_data[\\\"recording_mode\\\"] == TYPE_RECORD_MOTION\\n elif self._switch_type == \\\"record_always\\\":\\n return self._camera_data[\\\"recording_mode\\\"] == TYPE_RECORD_ALWAYS\\n elif self._switch_type == \\\"record_smart\\\":\\n return self._camera_data[\\\"recording_mode\\\"] == TYPE_RECORD_SMARTDETECT\\n elif self._switch_type == \\\"ir_mode\\\":\\n return self._camera_data[\\\"ir_mode\\\"] == self._ir_on_cmd\\n elif self._switch_type == \\\"hdr_mode\\\":\\n return self._camera_data[\\\"hdr_mode\\\"] is True\\n elif self._switch_type == \\\"high_fps\\\":\\n return self._camera_data[\\\"video_mode\\\"] == TYPE_HIGH_FPS_ON\\n else:\\n return self._camera_data[\\\"status_light\\\"] == \\\"True\\\"\",\n \"def is_active(self) -> bool:\\n return self.__is_active\",\n \"def is_active(self) -> bool:\",\n \"def is_active(self):\\n now = self.sim.now\\n return (now < self.stop) and (self._number < self.max_length) \\\\\\n and (now >= self.start)\",\n \"def _isInCamera(self, pos):\\n return self._isInScreen(self._posToScreenCoords(pos))\",\n \"def is_active():\\n return True\",\n \"def is_snap_enabled(self) -> bool:\\r\\n ...\",\n \"def is_on(self):\\n return self._brightness > 0 or self._white_value > 0\",\n \"def is_on(self):\\n return self._brightness != 0\",\n \"def is_active(self):\\n\\t\\tself.stream.is_active()\",\n \"def is_active(self) -> bool:\\n return self._is_active\",\n \"def is_recording(self):\\n return True if self._device.device_data[self._uuid]['streaming_state'] == \\\\\\n 'streaming-enabled' else False\",\n \"def isGrabando(self):\\n return self.grabando\",\n \"def _media_playback_trackable(self) -> bool:\\n if (\\n self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.Duration\\n is None\\n ):\\n return False\\n\\n return (\\n self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.Duration > 0\\n )\",\n \"def is_playing_dialtone(self) -> bool:\",\n \"def is_active(self):\\n with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True):\\n return self._action('is-active').succeeded\",\n \"def is_calibrated(self):\\n return self.gripper_io.get_signal_value(\\\"is_calibrated\\\")\",\n \"def hasCurrentFrame(self):\\n if self.currentFrame == []:\\n return False\\n return True\",\n \"def isPlaying(self):\\n return self.getChannel().get_busy()\",\n \"def check_mode(self):\\n if self.proximity.check_press():\\n self.cycle_mode()\\n return self.mode\",\n \"def is_active(self):\\n return bool(\\n self._grpc_port is not None and\\n self._event_multiplexer and\\n self._event_multiplexer.PluginRunToTagToContent(\\n constants.DEBUGGER_PLUGIN_NAME))\",\n \"def with_allows_camera(self):\\n return self.with_allowed_capture_methods(CAMERA)\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def is_active(self):\\n return True\",\n \"def enemyCaptured(self):\\n return self.game.team.flag.carrier != None\",\n \"def have_circ_pump(self):\\n return bool(self.circ_pump)\",\n \"def is_on(self) -> bool:\\n return self._zone.data[\\\"mode\\\"] == \\\"override\\\" and self._zone.data[\\\"setpoint\\\"]\",\n \"def CaptureMode(self):\\n if self.force_auto_sync:\\n self.get('CaptureMode')\\n return self._CaptureMode\",\n \"def is_smelling(self,conc_array):\\n if conc_array[int(self.x)][int(self.y)]>self.threshold:\\n self.smell_timer = self.Timer(self.T,self.lamda)\\n #Nav mode three and four need to know whether the moth is smelling\\n #at a specific moment, for that reason they use Tfirst.\\n self.Tfirst = self.T\\n self.odor = True #this datum will be useful in the graphical functions\\n return True\\n elif self.turned_on:\\n self.odor = False\\n if self.smell_timer.is_running(self.T):\\n return True #note - even though the there is no detection, the navigator stay in nav mode.\\n else:\\n self.odor = False\\n return False\",\n \"def is_on(self):\\n return self._light_on\",\n \"def get_allow_approx_motion(self):\\r\\n return self._arm.get_allow_approx_motion()\",\n \"def is_on(self):\\n return self.sec_start is not None and self.sec_stop is None\",\n \"def is_moving(self):\\n is_moving = self.get_raw_status() & self.STATUS_MOVING\\n return bool(is_moving)\",\n \"def active(self) -> bool:\\n return bool(self.log)\",\n \"def active(self) -> bool:\\n return self._active\",\n \"def is_active(self):\\r\\n return self.active\",\n \"def is_active(self):\\r\\n return True\",\n \"def is_on(self) -> bool:\\n return self._device.is_on\",\n \"def poll(cls, context):\\r\\n return context.object.animation_data.action is not None\",\n \"def is_active(self):\\n return self.active\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6876677","0.6634053","0.63762534","0.6186591","0.60965234","0.605035","0.6013605","0.6006316","0.5958077","0.59114885","0.5910525","0.5908825","0.5908825","0.58919317","0.58919317","0.5860505","0.5826048","0.5814718","0.5800764","0.5795898","0.5795898","0.5793163","0.57746214","0.5766827","0.5758039","0.5740444","0.5718584","0.57157695","0.56888545","0.5661974","0.5629394","0.56003344","0.5591478","0.5588408","0.5556276","0.554885","0.5546392","0.55257195","0.55193204","0.5501413","0.55004793","0.54954875","0.5491477","0.54790753","0.54722214","0.5447976","0.544247","0.54412055","0.5432231","0.5431761","0.5426235","0.542082","0.5420352","0.54194576","0.5414924","0.5412632","0.540663","0.5400619","0.53882617","0.53869444","0.5385682","0.53731537","0.53691375","0.53653145","0.5363592","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53628075","0.53567916","0.53524965","0.53511834","0.5348653","0.53385764","0.5335771","0.53265566","0.53258663","0.5324191","0.5316769","0.5309972","0.5306218","0.5299259","0.5291936","0.5284818","0.528345"],"string":"[\n \"0.6876677\",\n \"0.6634053\",\n \"0.63762534\",\n \"0.6186591\",\n \"0.60965234\",\n \"0.605035\",\n \"0.6013605\",\n \"0.6006316\",\n \"0.5958077\",\n \"0.59114885\",\n \"0.5910525\",\n \"0.5908825\",\n \"0.5908825\",\n \"0.58919317\",\n \"0.58919317\",\n \"0.5860505\",\n \"0.5826048\",\n \"0.5814718\",\n \"0.5800764\",\n \"0.5795898\",\n \"0.5795898\",\n \"0.5793163\",\n \"0.57746214\",\n \"0.5766827\",\n \"0.5758039\",\n \"0.5740444\",\n \"0.5718584\",\n \"0.57157695\",\n \"0.56888545\",\n \"0.5661974\",\n \"0.5629394\",\n \"0.56003344\",\n \"0.5591478\",\n \"0.5588408\",\n \"0.5556276\",\n \"0.554885\",\n \"0.5546392\",\n \"0.55257195\",\n \"0.55193204\",\n \"0.5501413\",\n \"0.55004793\",\n \"0.54954875\",\n \"0.5491477\",\n \"0.54790753\",\n \"0.54722214\",\n \"0.5447976\",\n \"0.544247\",\n \"0.54412055\",\n \"0.5432231\",\n \"0.5431761\",\n \"0.5426235\",\n \"0.542082\",\n \"0.5420352\",\n \"0.54194576\",\n \"0.5414924\",\n \"0.5412632\",\n \"0.540663\",\n \"0.5400619\",\n \"0.53882617\",\n \"0.53869444\",\n \"0.5385682\",\n \"0.53731537\",\n \"0.53691375\",\n \"0.53653145\",\n \"0.5363592\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53628075\",\n \"0.53567916\",\n \"0.53524965\",\n \"0.53511834\",\n \"0.5348653\",\n \"0.53385764\",\n \"0.5335771\",\n \"0.53265566\",\n \"0.53258663\",\n \"0.5324191\",\n \"0.5316769\",\n \"0.5309972\",\n \"0.5306218\",\n \"0.5299259\",\n \"0.5291936\",\n \"0.5284818\",\n \"0.528345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8491094"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":148,"numItemsPerPage":100,"numTotalItems":95772,"offset":14800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA2NDc3OSwianRpIjoiYmVmNTRmNDEtZjRhNC00YjhjLTllYjctNzBmZGE3NjE3Yjk0Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwNjgzNzksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.i87Foxcn-PGs7Mp8zEkr70sPisz1XWsBmY_m0OP8kUWTWIDw4pjGo7jR6wsKMkv1Aa6SDDogYbGvyzV21E51DA","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 |
|---|---|---|---|---|---|---|
Determine the ISO 6346 numeric equivalent of a character. | def code(char):
return int(char) if char.isdigit() else letter_code(char) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evalute_number(dialed):\n if (len(dialed) == 11 or len(dialed) == 10) and str(dialed).startswith(\"0\"):\n # UK Number\n return \"+44%s\" % (dialed[1:])\n elif len(dialed) == 6:\n # Local Fishguard numbers\n return \"+441348%s\" % (dialed)\n return None",
"def char_to_num... | [
"0.63106596",
"0.62892497",
"0.6242454",
"0.6229222",
"0.61676794",
"0.6138641",
"0.6134803",
"0.6132893",
"0.6048747",
"0.6008274",
"0.5899159",
"0.58616185",
"0.58511186",
"0.5842245",
"0.58217657",
"0.58190435",
"0.5784438",
"0.5782253",
"0.5777213",
"0.57736915",
"0.57563... | 0.61288404 | 8 |
Determine the ISO 6346 numeric code for a letter. | def letter_code(letter):
value = ord(letter.lower()) - ord('a') + 10
return value + value // 11 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def alpha_number(alpha):\r\n if alpha.isupper() == False:\r\n num = ord(alpha) - 96\r\n return num\r\n elif alpha.isupper() == True:\r\n num = ord(alpha) - 64\r\n return num",
"def code(char):\n return int(char) if char.isdigit() else letter_code(char)",
"def letter_num(num... | [
"0.7418329",
"0.7332461",
"0.6975198",
"0.6789075",
"0.6789075",
"0.67152506",
"0.65995985",
"0.65995985",
"0.65719616",
"0.6529032",
"0.64173263",
"0.6383725",
"0.63769406",
"0.63268995",
"0.6257811",
"0.62500453",
"0.62329525",
"0.6205183",
"0.61922914",
"0.6171451",
"0.606... | 0.73669213 | 1 |
Override parent method to use <= when finding nearest neighbours to ensure a neighbour is returned even at infinite/nan distance | def get_n_nearest_neighbors(self, query, n_neighbors):
if not isinstance(n_neighbors, int) or n_neighbors < 1:
raise ValueError('n_neighbors must be strictly positive integer')
neighbors = vptree._AutoSortingList(max_size=n_neighbors)
nodes_to_visit = [(self, 0)]
furthest_d =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_nearest_neighbour_1d(self):\n x = np.array([2., 1., 4., 5., 3.])\n x_new = np.array([-3, 0, 1.2, 3, 3, 2.5, 4.7, 6])\n val, ind = _nearest_neighbour_1d(x, x_new)\n np.testing.assert_array_equal(val, [1., 1., 1., 3., 3., 2., 5., 5.])\n np.testing.assert_array_equal(ind, [... | [
"0.68682957",
"0.6767455",
"0.6710233",
"0.6681611",
"0.6612519",
"0.65211624",
"0.6501286",
"0.6500969",
"0.6455676",
"0.6419788",
"0.63942283",
"0.6346417",
"0.63382214",
"0.63071793",
"0.6216757",
"0.6211591",
"0.61998034",
"0.61906844",
"0.6184552",
"0.61813545",
"0.61571... | 0.636207 | 11 |
Insert item into dynamic vp tree by first adding to pool, and then building a tree from the pool if min size reached Then merge trees of equal sizes so that there are at most log(log (n)) trees, with the largest tree having roughly n/2 nodes | def insert(self, item):
self.pool.append(item)
if len(self.pool) == self.min_tree_size:
self.trees.append(_ExtendedVPTree(self.pool, self.dist_fn))
self.pool = []
while len(self.trees) > 1 and self.trees[-1].size == self.trees[-2].size:
a = self.trees.pop()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bst_insert(sizes):\n tree = rbTree_main.BinarySearchTree();\n for i in range(sizes):\n tree.insert(random.random())",
"def rbt_insert(sizes):\n tree = rbTree_main.RBTree();\n for i in range(sizes):\n tree.rb_insert(random.random());\n pass",
"def _insort(self, node):\n l... | [
"0.65738744",
"0.59414244",
"0.58873856",
"0.5721595",
"0.5673607",
"0.5613784",
"0.5607082",
"0.5599457",
"0.5549631",
"0.54778767",
"0.5471518",
"0.53812885",
"0.5376035",
"0.53730154",
"0.53416336",
"0.5339837",
"0.5338522",
"0.5326516",
"0.5284125",
"0.52726436",
"0.52688... | 0.7945118 | 0 |
Return node nearest to query by finding nearest node in each tree and returning the global minimum (including nodes in pool) | def nearest(self, query):
nearest_trees = list(map(lambda t: t.get_nearest_neighbor(query), self.trees))
distances_pool = list(zip(map(lambda x: self.dist_fn(x, query), self.pool), self.pool))
best = None
best_cost = np.inf
for cost, near in nearest_trees + distances_pool:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nearest_neighbor(self, xRand):\n # TODO: Make this more efficient?\n #within a neighborhood of XRand, determine the lowest cost to go\n minCost = np.inf\n minNode = None\n\n for node in self.Tree:\n\n cost = self.compute_dist(node.state_time[0:6], xRand)\n\n ... | [
"0.73361427",
"0.73361427",
"0.73157585",
"0.72876966",
"0.7200594",
"0.71982765",
"0.7060152",
"0.70410466",
"0.69066334",
"0.6884978",
"0.68516064",
"0.6803381",
"0.67801213",
"0.6773021",
"0.67226744",
"0.6675192",
"0.6634299",
"0.66336787",
"0.66082364",
"0.65941596",
"0.... | 0.80384624 | 0 |
Return all nodes within distance radius of the given query, by collating neighbourhoods for each internal tree (and pool) | def neighbourhood(self, query, radius):
tree_neighbourhood = lambda tree: list(map(lambda x: x[1], tree.get_all_in_range(query, radius)))
neighbourhood_trees = list(itertools.chain.from_iterable(map(tree_neighbourhood, self.trees)))
return neighbourhood_trees + list(filter(lambda x: self.dist_fn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def neighbours(self):\n\n neighbours = []\n root = self.root\n if self == root:\n return neighbours\n\n ########################\n # IMMEDIATELY ADJACENT #\n sizes = [self.maxs[0] - self.mins[0], self.maxs[1] - self.mins[1]]\n coords = [(self.mins[0] + si... | [
"0.6189898",
"0.6067114",
"0.5967871",
"0.5918009",
"0.5853346",
"0.5850977",
"0.57527864",
"0.5742722",
"0.57373124",
"0.57318693",
"0.5728062",
"0.5716135",
"0.5708966",
"0.569612",
"0.5669883",
"0.5667582",
"0.5654472",
"0.5650004",
"0.5642539",
"0.56394213",
"0.5612371",
... | 0.79401344 | 0 |
Combine all processed data into a single dataset file. | def data_merge(detector_fields):
print("Merging final data...")
# load files that contain phase and I/O processed data and store as dfs
phase_data = pd.read_csv(results_folder + 'phases/processed/clean_merged_phases.csv', header=0,
skipinitialspace=True, usecols=output_fields)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_merge(path, dataset_name=\"processed_data\"):\n files = glob.glob(path+\"**//\"+dataset_name+\".json\")\n logger.info(\"Found {} files under the path {}\".format(len(files),path))\n final_data = []\n\n for file in files:\n assert dataset_name in file\n data = json.load(open(file,... | [
"0.6739214",
"0.66117465",
"0.6560573",
"0.6511757",
"0.6500883",
"0.6384844",
"0.6318141",
"0.6245312",
"0.6213231",
"0.617907",
"0.61625206",
"0.61625206",
"0.6154918",
"0.60871774",
"0.6077486",
"0.6057417",
"0.60547507",
"0.6008765",
"0.5997524",
"0.5996574",
"0.5979468",... | 0.5923977 | 22 |
Add a new pair of products with times purchased together if the pair existed, just increase the times purchased otherwise just add the new pair | def add(self, prod1_name, prod2_name, times):
if prod1_name == prod2_name:
return
try:
self._purchased.update({PROD1: prod1_name, PROD2: prod2_name, TIMES: {'$exists': True}},
{'$inc': {TIMES: times}},
True
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, product, order_type, pickup, drop, quantity=1, update_quantity=False):\n\n #calculate duratin\n start_date = datetime.strptime(pickup, \"%Y-%m-%d %H:%M\")\n end_date = datetime.strptime(drop, \"%Y-%m-%d %H:%M\")\n duration = end_date-start_date\n\n #end of calculati... | [
"0.6113706",
"0.6062423",
"0.6022032",
"0.57448155",
"0.5658234",
"0.5507529",
"0.54974794",
"0.5474968",
"0.5401568",
"0.5374355",
"0.5366406",
"0.5358892",
"0.5353692",
"0.5345051",
"0.53433794",
"0.5340769",
"0.53113306",
"0.529849",
"0.529575",
"0.5261819",
"0.52604914",
... | 0.65889096 | 0 |
Insert a list of pairs of products | def insert_product_list(self, prod_list):
try:
json_list = []
for item in prod_list:
json_list.append({PROD1: item[0], PROD2: item[1], TIMES: item[2]})
json_list.append({PROD1: item[1], PROD2: item[0], TIMES: item[2]})
if len(json_list) > 2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert_products(self):\n logic = ProductLogic()\n \n try:\n # We create the list of product objects\n products = self.objects_factory.create_product_object_list()\n products = set(products)\n\n for product in products:\n logic.inse... | [
"0.6807457",
"0.6570509",
"0.6336443",
"0.6255528",
"0.6255528",
"0.61996514",
"0.60343504",
"0.58767706",
"0.58759046",
"0.5782409",
"0.573562",
"0.57234836",
"0.57141703",
"0.5670095",
"0.5643585",
"0.56378525",
"0.5613349",
"0.55983883",
"0.5590104",
"0.5582928",
"0.557456... | 0.5663004 | 14 |
Add a list of pairs of products one by one | def add_product_list(self, prod_list):
success = True
for item in prod_list:
success &= self.add(item[0], item[1], item[2])
if success: print('add_product_list: succeeded')
else: print('add_product_list: failed')
return success | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pair_product(x1, x2):\n return np.multiply(x1, x2)",
"def _product(self, args):\n pools = map(tuple, args) #within original version args defined as *args\n result = [[]]\n for pool in pools:\n result = [x + [y] for x in result for y in pool]\n return result",
"def ... | [
"0.6781028",
"0.6746401",
"0.6640496",
"0.6640496",
"0.66049224",
"0.63687503",
"0.6310496",
"0.6284612",
"0.6192405",
"0.6176541",
"0.6154426",
"0.6141294",
"0.611274",
"0.6107433",
"0.60958445",
"0.6090736",
"0.60715026",
"0.6068512",
"0.6038685",
"0.6018187",
"0.5996263",
... | 0.6206119 | 8 |
Remove a pair of products | def remove(self, prod1_name, prod2_name):
try:
self._purchased.remove({PROD1: prod1_name, PROD2: prod2_name},
True
)
self._purchased.remove({PROD1: prod2_name, PROD2: prod1_name},
Tru... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_for_target(self, target, products):\n for product in products:\n self._products_by_target[target].discard(product)",
"def removeProduct(self, *args):\n return _libsbml.Reaction_removeProduct(self, *args)",
"def remove(self, pair):\n\n for plug in self.plugleads:\n if... | [
"0.65564406",
"0.6426297",
"0.6197446",
"0.6170158",
"0.6084325",
"0.5994371",
"0.5981625",
"0.5929859",
"0.5846611",
"0.58040714",
"0.57658505",
"0.5759781",
"0.57576233",
"0.5746318",
"0.5745949",
"0.5643254",
"0.56427234",
"0.5597372",
"0.55803734",
"0.55684996",
"0.556241... | 0.60259104 | 5 |
Assign a fixed times of the given pair of products with times purchased together | def assign(self, prod1_name, prod2_name, times):
try:
self._purchased.update({PROD1: prod1_name, PROD2: prod2_name},
{'$set': {TIMES: times}},
True
)
self._purchased.update({PROD1: pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def given_a_series_of_prices(self, prices):\n timestamps = [datetime(2015, 5, 28), datetime(2015, 5, 29),\n datetime(2015, 5, 30)]\n for timestamp, price in zip(timestamps, prices):\n self.goog.update(timestamp, price)",
"def promotion(time, sum_price):\n time = s... | [
"0.56735665",
"0.5642687",
"0.5597733",
"0.55516917",
"0.55381095",
"0.54918313",
"0.5367134",
"0.53548855",
"0.53330797",
"0.5317737",
"0.5311256",
"0.5310855",
"0.5292983",
"0.5248051",
"0.5220131",
"0.52120817",
"0.5160664",
"0.51471895",
"0.51454437",
"0.51453066",
"0.514... | 0.5754572 | 0 |
Recommend the next best relevant product | def recommend_next_product(self, prod_list):
scores = defaultdict(float)
for prod in prod_list:
for item in self._purchased.find({PROD1: prod}):
if not item[PROD2] in prod_list:
scores[item[PROD2]] += math.log(item[TIMES])
if len(scores) == 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _choose_best_option(self):",
"def popular_recommend(row):\n actual = new_purchase_row(row)\n return f1(actual, popular_products)",
"def step(self):\n highest_offer = None\n\n if self.manager is None:\n highest_rep = 0\n\n else:\n highest_rep = self.manager.r... | [
"0.6451906",
"0.6248928",
"0.6203764",
"0.6144406",
"0.610878",
"0.60792506",
"0.59292257",
"0.579324",
"0.57634926",
"0.5680954",
"0.56799036",
"0.56428087",
"0.56206936",
"0.55952084",
"0.55937326",
"0.5577743",
"0.5574243",
"0.5536686",
"0.55234545",
"0.55225116",
"0.54792... | 0.69993323 | 0 |
Get the of times this pair has been purchased together | def get_times(self, prod1_name, prod2_name):
try:
item = self._purchased.find_one({PROD1: prod1_name, PROD2: prod2_name})
if item == None: return None
else: return item[TIMES]
except pyerrors.OperationFailure as ex:
print(ex.value)
except pyerrors.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTimes():",
"def getTimes():",
"def getTimes():",
"def report(self):\n result = {}\n result_buy = 0\n result_sell = 0\n result_outcome = 0\n for pair in self.pairs:\n orders = self.get_orders_for(pair)\n buy, sell = self.get_buy_and_sell_costs(or... | [
"0.5729796",
"0.5729796",
"0.5729796",
"0.5604218",
"0.5600595",
"0.5598839",
"0.5565004",
"0.5493396",
"0.54700637",
"0.54325604",
"0.5373735",
"0.53556556",
"0.53387326",
"0.5308763",
"0.52820003",
"0.5280199",
"0.52264136",
"0.5214018",
"0.52127707",
"0.52127707",
"0.51249... | 0.55778635 | 6 |
Trains the classifier model on the training set stored in file trainfile | def train(self, trainfile):
sentences_emb,labels=self.read_data(trainfile)
logReg = LogisticRegression(penalty="l2",C = 10, multi_class='auto',solver='newton-cg')
logReg.fit(sentences_emb,labels)
self.clf=logReg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self, trainfile):",
"def trainModel( self, featureTrain, classTrain):",
"def train(self):\n self.log(f\"{self.cur_file_path}\\t\\tInfo: train method invoked!\")\n self.log(f\"{self.cur_file_path}\\t\\tInfo: training {self.model.__class__.__name__} model!\")\n\n self.model.fit(sel... | [
"0.8426095",
"0.74116445",
"0.73872614",
"0.72419417",
"0.71222615",
"0.7112658",
"0.7041241",
"0.70203024",
"0.7007973",
"0.69176805",
"0.69125766",
"0.6865418",
"0.6846726",
"0.68443483",
"0.68333745",
"0.68271935",
"0.6823557",
"0.6811905",
"0.6811905",
"0.6811905",
"0.681... | 0.7566852 | 1 |
Predicts class labels for the input instances in file 'datafile' Returns the list of predicted labels | def predict(self, datafile):
sentences_emb,labels=self.read_data(datafile)
predictions=self.clf.predict(sentences_emb)
polarity=[]
for p in predictions:
if p==1:
polarity.append("positive")
elif p==0:
polarity.append("neutra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, data):\n xdata, _ = self.array_from_cases(data)\n preds = self.model.predict(xdata)\n label_preds = [dict(zip(self.binarizer.classes_, pred)) for pred in preds]\n return label_preds",
"def predict(self, datafile):",
"def predict(self, test_file_path: str) -> List[D... | [
"0.76404834",
"0.7387015",
"0.71751606",
"0.7162944",
"0.7094534",
"0.6908485",
"0.6878635",
"0.6853093",
"0.6816419",
"0.68157095",
"0.6622839",
"0.6621277",
"0.6613741",
"0.65917116",
"0.65894985",
"0.6565011",
"0.65631646",
"0.65263724",
"0.6513915",
"0.6501854",
"0.650169... | 0.7219323 | 2 |
Read the meta information from the FPG file. | def get_wb_addresses(filename):
if filename is not None:
fptr = open(filename, 'r')
firstline = fptr.readline().strip().rstrip('\n')
if firstline != '#!/bin/kcpfpg':
fptr.close()
raise RuntimeError('%s does not look like an fpg file we can '
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_meta(metafn=None):\n\n metadata = {}\n\n # potential future improvement: strip quotation marks from strings, where applicable. Will then need to adjust\n # the indices used to get the dates and times in the functions above \n # (get_DEM_img_times: dtstrings = {\"sourceImage1\":(5,19, '%Y%m%d%H... | [
"0.7055493",
"0.70491713",
"0.6815708",
"0.678142",
"0.66057986",
"0.63837147",
"0.6364409",
"0.6312615",
"0.6274537",
"0.6261746",
"0.62187535",
"0.61309636",
"0.6101534",
"0.6093043",
"0.609194",
"0.6075726",
"0.60565966",
"0.60202336",
"0.6020089",
"0.6008801",
"0.6007056"... | 0.0 | -1 |
load_data takes path and loads in the dataset identified in this project into a pandas df. It then prints high level information about the dataframe for the users reference and returns this dataframe | def load_data(path):
columns = ['Item Year', 'Original Value', 'Standard Value', 'Original Currency',
'Standard Currency', 'Orignal Measure', 'Standard Measure', 'Location',
'Commodity']
col_type = [int, float, float, object, object, object, object, object]
col_type_dict = di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data():\n df = pd.read_csv(\"https://raw.githubusercontent.com/Andrea-Giuliani/Python-Project/master/data/final_dataset.csv\",sep=',') \n return df",
"def loadData(path_file):\n data = pd.read_csv(path_file) \n data.head()\n return data",
"def load_data():\n \n data = datasets.lo... | [
"0.67460644",
"0.64907336",
"0.64832234",
"0.6358895",
"0.63168895",
"0.62954944",
"0.62547684",
"0.6236128",
"0.6230134",
"0.6215533",
"0.6180172",
"0.61594254",
"0.6152189",
"0.6103808",
"0.6073373",
"0.6071692",
"0.6057447",
"0.6054861",
"0.6051355",
"0.6035068",
"0.602572... | 0.0 | -1 |
Method to apply ET Conformance | def apply(log, net, marking, final_marking, parameters=None, variant=None):
if parameters is None:
parameters = {}
log = log_conversion.apply(log, parameters, log_conversion.TO_EVENT_LOG)
# execute the following part of code when the variant is not specified by the user
if variant is No... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inferSpecification(inputExamples, outputExamples, components):",
"def uncertainty_ee(self,e1,e2):\n # reco\n unc = (self._eleRecoWeight[(e1.pt(),e1.eta())][1]/self._eleRecoWeight[(e1.pt(),e1.eta())][0] + \\\n self._eleRecoWeight[(e2.pt(),e2.eta())][1]/self._eleRecoWeight[(e2.pt(),e2.eta... | [
"0.520668",
"0.5201455",
"0.5150791",
"0.48542607",
"0.48534966",
"0.48262239",
"0.48014283",
"0.4788974",
"0.47726873",
"0.47622526",
"0.47622526",
"0.47534707",
"0.472562",
"0.4701052",
"0.46974584",
"0.4674532",
"0.4657097",
"0.46532992",
"0.46299773",
"0.46085578",
"0.460... | 0.0 | -1 |
Convenience split function for inverted index attributes. Useful for attributes that contain filenames. Splits the given string s into components parts (directories, filename), discarding the extension and all but the last two directories. What's remaining is split into words and the result is returned. | def split_path(s):
dirname, filename = os.path.split(s)
fname_noext, ext = os.path.splitext(filename)
levels = dirname.strip('/').split(os.path.sep)[2:][-2:]
return PATH_SPLIT.split(' '.join(levels + [fname_noext])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_path(s):\n dirname, filename = os.path.split(s)\n fname_noext, ext = os.path.splitext(filename)\n for part in dirname.strip('/').split(os.path.sep)[2:][-2:] + [fname_noext]:\n for match in PATH_SPLIT.split(part):\n if match:\n yield match",
"def tokenize(\n ... | [
"0.63968426",
"0.6263762",
"0.61884594",
"0.58648413",
"0.5765297",
"0.5761506",
"0.5726431",
"0.56870097",
"0.56813276",
"0.56165",
"0.55843884",
"0.5512251",
"0.5427378",
"0.5423563",
"0.54086035",
"0.5384905",
"0.5383309",
"0.5346063",
"0.53299356",
"0.52875656",
"0.528058... | 0.7065876 | 0 |
Takes a list of mixed types and outputs a unicode string. For example, a list [42, 'foo', None, "foo's' string"], this returns the | def _list_to_printable(value):
fixed_items = []
for item in value:
if type(item) in (int, long, float):
fixed_items.append(str(item))
elif item == None:
fixed_items.append("NULL")
elif type(item) == unicode:
fixed_items.append("'%s'" % item.replace("'",... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_list_to_unicode_str(data):\n string = ''\n for i, val in enumerate(data):\n # string = string + unicode(unichr(int(val)))\n string = string + str(int(val))\n return string",
"def _get_types_string(types_list):\n type_str = \"\"\n for type in types_list:\n type_str ... | [
"0.70956445",
"0.6905875",
"0.66197217",
"0.6430419",
"0.60457647",
"0.6029881",
"0.5985099",
"0.5957578",
"0.5839138",
"0.58388275",
"0.5828249",
"0.579073",
"0.57889533",
"0.57728666",
"0.57434475",
"0.57249594",
"0.5704203",
"0.5672486",
"0.56484795",
"0.56462157",
"0.5625... | 0.6718685 | 2 |
Registers one or more object attributes and/or multicolumn indexes for the given type name. This function modifies the database as needed to accommodate new indexes and attributes, either by creating the object's tables (in the case of a new object type) or by altering the object's tables to add new columns or indexes.... | def register_object_type_attrs(self, type_name, indexes = [], **attrs):
if len(indexes) == len(attrs) == 0:
raise ValueError, "Must specify indexes or attributes for object type"
table_name = "objects_%s" % type_name
# First pass over the attributes kwargs, sanity-checking provided... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_object_type_attrs(self, type_name, indexes = [], **attrs):\n if len(indexes) == len(attrs) == 0:\n raise ValueError(\"Must specify indexes or attributes for object type\")\n\n table_name = \"objects_%s\" % type_name\n\n # First pass over the attributes kwargs, sanity-ch... | [
"0.77066755",
"0.6361328",
"0.6264673",
"0.61884093",
"0.5833767",
"0.57452655",
"0.57315993",
"0.56269467",
"0.54736567",
"0.544051",
"0.54389435",
"0.5431951",
"0.53999454",
"0.5295605",
"0.52132535",
"0.5177261",
"0.5129444",
"0.51156485",
"0.5099704",
"0.50790924",
"0.505... | 0.7726764 | 0 |
Registers a new inverted index with the database. An inverted index maps arbitrary terms to objects and allows you to query based on one or more terms. If the inverted index already exists with the given parameters, no action is performed. name is the name of the inverted index and must be alphanumeric. min and max spe... | def register_inverted_index(self, name, min = None, max = None, split = None, ignore = None):
# Verify specified name doesn't already exist as some object attribute.
for object_name, object_type in self._object_types.items():
if name in object_type[1] and name != object_type[1][name][2]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_inverted_index(self, name, min = None, max = None, split = None, ignore = None):\n # Verify specified name doesn't already exist as some object attribute.\n for object_name, object_type in self._object_types.items():\n if name in object_type[1] and name != object_type[1][name]... | [
"0.8106289",
"0.5157404",
"0.513424",
"0.49950093",
"0.4974171",
"0.48789895",
"0.48250076",
"0.47591364",
"0.47572297",
"0.4660967",
"0.46581295",
"0.46503413",
"0.464838",
"0.46435705",
"0.46280825",
"0.46089694",
"0.46081924",
"0.4605972",
"0.4580362",
"0.4576036",
"0.4573... | 0.81983155 | 0 |
Deletes the specified object. | def delete_object(self, (object_type, object_id)):
return self._delete_multiple_objects({object_type: (object_id,)}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_object(self, object):\n object.delete()",
"def delete(self, obj=None):\n pass",
"def delete(self, obj=None):\n if obj is not None:\n key = \"{}.{}\".format(type(obj).__name__, obj.id)\n try:\n del self.__objects[key]\n except KeyEr... | [
"0.8609504",
"0.84928817",
"0.8423077",
"0.8405551",
"0.8397232",
"0.83793044",
"0.83793044",
"0.83793044",
"0.83793044",
"0.8377723",
"0.83596385",
"0.83385885",
"0.83169276",
"0.83169276",
"0.83169276",
"0.81342936",
"0.8100833",
"0.80617315",
"0.8013819",
"0.7979763",
"0.7... | 0.8175527 | 15 |
Deletes all objects returned by the given query. See query() for argument details. Returns number of objects deleted. | def delete_by_query(self, **attrs):
attrs["attrs"] = ["id"]
results = self.query(**attrs)
if len(results) == 0:
return 0
results_by_type = {}
for o in results:
if o["type"] not in results_by_type:
results_by_type[o["type"]] = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_by_query(self, query, params = {}):\n params['hitsPerPage'] = 1000\n params['attributesToRetrieve'] = ['objectID']\n\n res = self.search(query, params)\n while (res['nbHits'] != 0):\n object_ids = []\n for elt in res['hits']:\n object_ids.... | [
"0.76967055",
"0.75710857",
"0.7238022",
"0.7166252",
"0.70217574",
"0.6912766",
"0.6698922",
"0.65711296",
"0.6482522",
"0.647761",
"0.6437574",
"0.64066416",
"0.63698435",
"0.6357176",
"0.6343275",
"0.6333492",
"0.6290694",
"0.6279942",
"0.6258179",
"0.62489057",
"0.6222344... | 0.71112645 | 5 |
Adds an object of type 'object_type' to the database. Parent is a (type, id) tuple which refers to the object's parent. 'object_type' and 'type' is a type name as given to register_object_type_attrs(). attrs kwargs will vary based on object type. ATTR_SIMPLE attributes which a None are not added. This method returns th... | def add(self, object_type, parent = None, **attrs):
type_attrs = self._get_type_attrs(object_type)
if parent:
attrs["parent_type"] = self._get_type_id(parent[0])
attrs["parent_id"] = parent[1]
# Increment objectcount for the applicable inverted indexes.
inverted_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Add(self, obj_type, name, node=None, obj=None):\n print \"Adding object %s, node: %s\" % (name, node)\n #check for duplicate object\n # also raise error if no such object type\n if self.ObjectExists(obj_type, name):\n raise DuplicateObjectError(name)\n \n ... | [
"0.6409624",
"0.62771475",
"0.60935414",
"0.6087404",
"0.60587406",
"0.5914331",
"0.5884166",
"0.55695456",
"0.5552869",
"0.53761256",
"0.53064",
"0.52908915",
"0.5275135",
"0.5275135",
"0.5275135",
"0.5275135",
"0.5275135",
"0.52567697",
"0.514278",
"0.51280934",
"0.5127361"... | 0.6481042 | 0 |
Update an object in the database. For updating, object is identified by a (type, id) tuple or an ObjectRow instance. Parent is a (type, id) tuple or ObjectRow instance, which refers to the object's parent. If specified, the object is reparented, otherwise the parent remains the same as when it was added with add(). att... | def update(self, obj, parent=None, **attrs):
if isinstance(obj, ObjectRow):
object_type, object_id = obj['type'], obj['id']
else:
object_type, object_id = obj
type_attrs = self._get_type_attrs(object_type)
get_pickle = False
# Determine which inverted in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, obj, parent=None, **attrs):\n if self._readonly:\n raise DatabaseReadOnlyError('upgrade_to_py3() must be called before database can be modified')\n object_type, object_id = self._to_obj_tuple(obj)\n\n type_attrs = self._get_type_attrs(object_type)\n get_pickl... | [
"0.74381167",
"0.6614651",
"0.6315451",
"0.61962694",
"0.614676",
"0.6144914",
"0.6054113",
"0.6040945",
"0.5997564",
"0.5952653",
"0.5952653",
"0.59390825",
"0.59053296",
"0.5887963",
"0.5873624",
"0.5767497",
"0.57389915",
"0.57276726",
"0.5707913",
"0.5680127",
"0.5647404"... | 0.786734 | 0 |
Query the database for objects matching all of the given attributes | def query(self, **attrs):
query_info = {}
parents = []
query_type = "ALL"
results = []
query_info["columns"] = {}
query_info["attrs"] = {}
if "object" in attrs:
attrs["type"], attrs["id"] = attrs["object"]
del attrs["object"]
ivti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_all(cls, **kwargs):\n return cls.query.filter_by(**kwargs).all()",
"def find(cls, attrs):\n return [cls(data) for data in cls.db().find(attrs, True)]",
"def findall(cls, *lst, **dct):\n query = cls.where(*lst, **dct).select()\n result = query.execute()\n return resul... | [
"0.6990179",
"0.6830054",
"0.6592934",
"0.6471972",
"0.6471972",
"0.64145225",
"0.6377542",
"0.6299601",
"0.6221802",
"0.613642",
"0.61021376",
"0.60580194",
"0.6044587",
"0.60377383",
"0.6028511",
"0.6022793",
"0.60128856",
"0.60116005",
"0.5982548",
"0.5980463",
"0.5961357"... | 0.596369 | 20 |
Scores the terms given in terms_list, which is a list of tuples (terms, coeff, split, ivtidx), where terms is the string or sequence of terms to be scored, coeff is the weight to give each term in this part (1.0 is normal), split is the function or regular expression used to split terms (only used if a string is given ... | def _score_terms(self, terms_list):
terms_scores = {}
total_terms = 0
for terms, coeff, split, ivtidx in terms_list:
if not terms:
continue
# Swap ivtidx name for inverted index definition dict
ivtidx = self._inverted_indexes[ivtidx]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _score_terms(self, terms_list):\n terms_scores = {}\n total_terms = 0\n\n for terms, coeff, split, ivtidx in terms_list:\n if not terms:\n continue\n # Swap ivtidx name for inverted index definition dict\n ivtidx = self._inverted_indexes[ivti... | [
"0.8230414",
"0.54937506",
"0.54905194",
"0.5479236",
"0.5440691",
"0.5430716",
"0.54254556",
"0.5392035",
"0.53528565",
"0.51504266",
"0.5112394",
"0.510215",
"0.5097729",
"0.50681865",
"0.5062038",
"0.4980558",
"0.49433053",
"0.49381447",
"0.49258786",
"0.49234137",
"0.4917... | 0.82383937 | 0 |
Removes all indexed terms under the specified inverted index for the given object. This function must be called when an object is removed from the database, or when an ATTR_INVERTED_INDEX attribute of an object is being updated (and therefore that inverted index must be reindexed). | def _delete_object_inverted_index_terms(self, (object_type, object_id), ivtidx):
self._delete_multiple_objects_inverted_index_terms({object_type: ((ivtidx,), (object_id,))}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delete_object_inverted_index_terms(self, obj, ivtidx):\n object_type, object_id = obj\n self._delete_multiple_objects_inverted_index_terms({object_type: ((ivtidx,), (object_id,))})",
"def _delete_multiple_objects_inverted_index_terms(self, objects):\n for type_name, (ivtidxes, object_id... | [
"0.81035614",
"0.75411546",
"0.75411546",
"0.6139424",
"0.6045582",
"0.603692",
"0.6007786",
"0.60001457",
"0.59316987",
"0.584059",
"0.5829414",
"0.5817072",
"0.5789952",
"0.57787883",
"0.5730306",
"0.56770205",
"0.56318223",
"0.5610385",
"0.55822736",
"0.5505812",
"0.549647... | 0.80202085 | 1 |
objects = dict type_name > (ivtidx tuple, ids tuple) | def _delete_multiple_objects_inverted_index_terms(self, objects):
for type_name, (ivtidxes, object_ids) in objects.items():
# Resolve object type name to id
type_id = self._get_type_id(type_name)
for ivtidx in ivtidxes:
# Remove all terms for the inverted ind... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def theidfobjectmentioningobjs(idfindex, keyindex, objindex):\n idf, edges = eppystuff.an_idfedges(idfindex)\n objnames = idf_helpers.idfobjectkeys(idf)\n objname = objnames[keyindex]\n idfobjects = idf.idfobjects[objname]\n idfobject = idfobjects[objindex]\n from eppy import walk_hvac\n try:\... | [
"0.62619203",
"0.6195102",
"0.6129353",
"0.60668653",
"0.60668653",
"0.60462576",
"0.59726316",
"0.5910517",
"0.5824511",
"0.5824511",
"0.5769879",
"0.574441",
"0.5735872",
"0.5715742",
"0.5715742",
"0.5702065",
"0.5692871",
"0.56785494",
"0.56541747",
"0.56099105",
"0.560706... | 0.49538565 | 88 |
Adds the dictionary of terms (as computed by _score_terms()) to the specified inverted index database for the given object. | def _add_object_inverted_index_terms(self, (object_type, object_id), ivtidx, terms):
if not terms:
return
# Resolve object type name to id
object_type = self._get_type_id(object_type)
# Holds any of the given terms that already exist in the database
# with their id ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_object_inverted_index_terms(self, obj, ivtidx, terms):\n object_type, object_id = obj\n if not terms:\n return\n\n # Resolve object type name to id\n object_type = self._get_type_id(object_type)\n\n # Holds any of the given terms that already exist in the data... | [
"0.8023277",
"0.61256963",
"0.5922523",
"0.57880175",
"0.5704644",
"0.56919354",
"0.56858873",
"0.56835586",
"0.56740934",
"0.56609404",
"0.56487274",
"0.5621855",
"0.56036234",
"0.55900854",
"0.5573914",
"0.5557396",
"0.5548084",
"0.5533701",
"0.55311424",
"0.53814083",
"0.5... | 0.7867361 | 1 |
Queries the inverted index ivtidx for the terms supplied in the terms argument. If terms is a string, it is parsed into individual terms based on the split for the given ivtidx. The terms argument may also be a list or tuple, in which case no parsing is done. The search algorithm tries to optimize for the common case. ... | def _query_inverted_index(self, ivtidx, terms, limit = 100, object_type = None):
t0 = time.time()
# Fetch number of files the inverted index applies to. (Used in score
# calculations.)
objectcount = self._inverted_indexes[ivtidx]['objectcount']
if not isinstance(terms, (list, t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _query_inverted_index(self, ivtidx, terms, limit = 100, object_type = None):\n t0 = time.time()\n # Fetch number of files the inverted index applies to. (Used in score\n # calculations.)\n objectcount = self._inverted_indexes[ivtidx]['objectcount']\n\n if not isinstance(term... | [
"0.7995925",
"0.75903076",
"0.74195915",
"0.64581156",
"0.6457221",
"0.59554505",
"0.5865238",
"0.5861748",
"0.58322316",
"0.5811512",
"0.5693761",
"0.5638802",
"0.5617676",
"0.5603782",
"0.55951315",
"0.55166435",
"0.530402",
"0.5279322",
"0.52687097",
"0.52252996",
"0.51968... | 0.8012516 | 0 |
Obtains terms for the given inverted index name. If associated is None, all terms for the inverted index are returned. The return value is a list of 2tuples, where each tuple is (term, count). Count is the total number of objects that term is mapped to. Otherwise, associated is a specified list of terms, and only those... | def get_inverted_index_terms(self, ivtidx, associated = None, prefix = None):
if ivtidx not in self._inverted_indexes:
raise ValueError, "'%s' is not a registered inverted index." % ivtidx
if prefix:
where_clause = 'WHERE terms.term >= ? AND terms.term <= ?'
where_va... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_inverted_index_terms(self, ivtidx, associated = None, prefix = None):\n if ivtidx not in self._inverted_indexes:\n raise ValueError(\"'%s' is not a registered inverted index.\" % ivtidx)\n\n if prefix:\n where_clause = 'WHERE terms.term >= ? AND terms.term <= ?'\n ... | [
"0.72814137",
"0.5312216",
"0.51168823",
"0.50760156",
"0.5040851",
"0.49835056",
"0.48447284",
"0.4833117",
"0.48034608",
"0.47988817",
"0.4782228",
"0.46925923",
"0.46841052",
"0.4615586",
"0.461366",
"0.45966607",
"0.45822227",
"0.45699117",
"0.45678702",
"0.45583963",
"0.... | 0.7293714 | 0 |
Test that trailing @ used for extracting does not interfere with untag. | def test_untag_with_trailing_extract(self):
fields_to_test = {
'foo@': 'bar-base',
'foo@de@': 'bar-de',
'foo@(.*_FR|.*_SG)@': 'bar-fr',
'nested': {
'nested@': 'nested-base',
'nested@de_AT@': 'nested-de',
'nested@(.*_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mention(result):\n return result.text.find('@') != -1",
"def testUnindentedFields(self):\n self.checkParse(\"\"\"\n This is a paragraph.\n \n @foo: This is a field.\"\"\")\n \n self.checkParse(\"\"\"\n This is a paragraph.\n @foo: This is a field.\"\... | [
"0.6034205",
"0.59515476",
"0.59357536",
"0.58285934",
"0.57458454",
"0.54263383",
"0.5389915",
"0.5322321",
"0.53162247",
"0.527235",
"0.5249418",
"0.5217515",
"0.5167631",
"0.5140492",
"0.5128733",
"0.5124771",
"0.5098799",
"0.5088662",
"0.50590724",
"0.5033587",
"0.5031845... | 0.6260769 | 0 |
Test that not having a base key does not interfere with untag and locales. | def test_untag_with_no_base(self):
fields_to_test = {
'foo@de': 'bar-de',
'baz@de': {
'fum@de': 'boo-de'
},
}
fields = copy.deepcopy(fields_to_test)
self.assertDictEqual({}, document_fields.DocumentFields.untag(fields))
self.ass... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unset_key(self):\n context = {'help_key': 'unused-key'}\n self.assertRaises(\n ImproperlyConfigured,\n tags.madcap_flare_help,\n context)",
"def __missing__(self, key):\n global MISSING\n MISSING = key # For debugging - save name of missing k... | [
"0.61089957",
"0.60943186",
"0.6040597",
"0.60356236",
"0.58925235",
"0.58480316",
"0.5847725",
"0.5817884",
"0.5728378",
"0.5715855",
"0.57137895",
"0.57015187",
"0.5691672",
"0.5673796",
"0.56599385",
"0.56495875",
"0.5617581",
"0.56079537",
"0.5602262",
"0.55924207",
"0.55... | 0.6586597 | 0 |
Untag when there is a none value for the tagged value. | def test_untag_none(self):
untag = document_fields.DocumentFields.untag
fields_to_test = {
'foo': 'base',
'foo@env.prod': None,
}
fields = copy.deepcopy(fields_to_test)
self.assertDictEqual({
'foo': 'base',
}, untag(fields, locale=None,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self, value):\n tags = self.__all_tags()\n if value in tags:\n tags.remove(value)\n self.__post_changes(tags)",
"def testNoneValue(self):\n objectID = uuid4()\n user = createUser(u'username', u'password', u'User',\n u'user@exam... | [
"0.6135915",
"0.5967588",
"0.59159297",
"0.580774",
"0.57716626",
"0.57520264",
"0.56370187",
"0.56107867",
"0.5567301",
"0.5549925",
"0.55275375",
"0.55266446",
"0.54774225",
"0.5460869",
"0.54421735",
"0.54349834",
"0.54182965",
"0.54049665",
"0.5401856",
"0.5396873",
"0.53... | 0.64906526 | 0 |
Test that updates properly overwrite and are untagged. | def test_update(self):
doc_fields = document_fields.DocumentFields({
'foo@': 'bar',
})
self.assertEquals('bar', doc_fields['foo'])
doc_fields.update({
'foo@': 'bbq',
})
self.assertEquals('bbq', doc_fields['foo']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update(self):\n pass",
"def test_update(self):\n pass",
"def test_update(self):\n pass",
"def test_update_case(self):\n pass",
"def test_update_metadata(self):\n pass",
"def test_update_metadata1(self):\n pass",
"def test_partial_update_metadata(self):... | [
"0.723041",
"0.723041",
"0.723041",
"0.7100334",
"0.7058294",
"0.70286316",
"0.6987502",
"0.69788766",
"0.68703234",
"0.6843875",
"0.6841047",
"0.680045",
"0.67363405",
"0.66987944",
"0.66319287",
"0.6622596",
"0.6543176",
"0.6509451",
"0.6463772",
"0.6427286",
"0.6409471",
... | 0.59169775 | 86 |
Summary of the time series. include mean, std, max, min and range | def summaryone(x):
print 'mean and std are ',np.mean(x), np.std(x)
print 'max and min are ',np.max(x), np.min(x)
print 'the range is ',np.max(x)-np.min(x) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_time_series_stats(time_series):\n return pd.Series([np.mean(time_series), np.std(time_series), get_frequency(time_series)])",
"def show_stats(x):\n print(\"min =\", x.min())\n print(\"max =\", x.max())\n print(\"median =\", np.median(x))\n print(\"average =\", x.mean())\n print(\"std =\... | [
"0.6649429",
"0.6533868",
"0.6494436",
"0.64276904",
"0.63289535",
"0.6307185",
"0.62566227",
"0.6218539",
"0.6188114",
"0.6148697",
"0.6121931",
"0.60502344",
"0.6021406",
"0.60148054",
"0.5986059",
"0.59573406",
"0.5942241",
"0.5935031",
"0.5930992",
"0.5924357",
"0.5903259... | 0.7294873 | 0 |
Plot and save one time series. | def plotone(x,y,xlabel,ylabel,filename):
fig=plt.figure()
ax = fig.add_subplot(111)
ax.plot(x,y,linewidth=2.0)
plt.ylabel(ylabel)
plt.xlabel(xlabel)
fig.savefig(filename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_timeseries(self, series):\n plt.plot(range(1, len(series) + 1), series)\n plt.title(self.ticker)\n plt.savefig('plots/ARIMA/{0}.pdf'.format(self.ticker))\n plt.show()",
"def plot2dTimeSeries(values, title='series', xLabel='time', yLabel='values', savePath='.'):\n plt.plot(... | [
"0.74593556",
"0.73596394",
"0.71248585",
"0.70842844",
"0.684327",
"0.6759598",
"0.67345",
"0.6571536",
"0.65034944",
"0.64912015",
"0.64470774",
"0.64422935",
"0.63846207",
"0.63799745",
"0.63796836",
"0.6315035",
"0.6307601",
"0.6282471",
"0.62733847",
"0.6260635",
"0.6247... | 0.6692859 | 7 |
Plot two series in one plot. | def plottwo(x,y1,y2,y1label,y2label,xlabel,ylabel,filename):
fig=plt.figure()
ax = fig.add_subplot(111)
ax.plot(x,y1,'ro-',linewidth=2.0,label=y1label)
ax.plot(x,y2,'gs--',linewidth=2.0, label=y2label)
plt.ylabel(ylabel)
plt.xlabel(xlabel)
plt.legend()
fig.savefig(filename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_series(self, t1=0, t2=100, t1p=None, t2p=None):\n \n plot_discretized(self.ts, self.ts_dis, t1=t1, t2=t2, t1p=t1p, t2p=t2p)",
"def plot_corr_diff(tseries1, tseries2, fig=None,\r\n ts_names=['1', '2']):\r\n\r\n if fig is None:\r\n fig = plt.figure()\r\n\r\n ax ... | [
"0.6800669",
"0.6607004",
"0.64603275",
"0.6359338",
"0.63104266",
"0.6293461",
"0.627208",
"0.6260561",
"0.6245822",
"0.616296",
"0.61425745",
"0.61307013",
"0.60872036",
"0.60725236",
"0.60658973",
"0.6039061",
"0.6036746",
"0.60297143",
"0.6007434",
"0.60052645",
"0.596451... | 0.6087972 | 12 |
Creates and returns a MySQL database engine. | def create_mysql_engine(dbname, prod=True, driver="pymysql"):
db_config = toolbox.open_system_config(prod=prod, config_type="DB_CONFIG")[dbname]
db_url = URL(
drivername="mysql+{}".format(driver),
username=db_config.get("username"),
password=db_config.get("password"),
host=db_con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_mysql_engine():\n\n return sa.create_engine(\n sa.engine.url.URL(\n drivername=\"mysql+pymysql\",\n username=\"username\", # Change that!!\n password=\"password\", # Change that!!\n host=\"host\", # Change that!!\n port=c.PORT,\n ... | [
"0.77028465",
"0.75408655",
"0.740179",
"0.73909706",
"0.71847886",
"0.7134698",
"0.7087348",
"0.70744014",
"0.7018489",
"0.6846384",
"0.679343",
"0.6783817",
"0.676985",
"0.670791",
"0.670791",
"0.670791",
"0.670791",
"0.66787875",
"0.66645664",
"0.6635707",
"0.6618998",
"... | 0.7968073 | 0 |
Creates and returns a connection to a Microsoft SQL Server database. | def create_mssql_connection(
dbname, prod=True, driver="{ODBC Driver 17 for SQL Server}", driver_type="pyodbc"
):
db_config = toolbox.open_system_config(prod=prod, config_type="DB_CONFIG")[dbname]
if driver_type == "pyodbc":
connection = pyodbc.connect(
driver=driver,
server=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createConnection(self):\n comp_name = os.environ['COMPUTERNAME']\n conn = py.connect('Driver=ODBC Driver 11 for SQL Server;SERVER=' +\n comp_name + '\\HAZUSPLUSSRVR; UID=SA;PWD=Gohazusplus_02')\n self.conn = conn\n return conn",
"def create_connection():\r\n tr... | [
"0.69744205",
"0.6950537",
"0.67107075",
"0.64784396",
"0.6422242",
"0.6395865",
"0.638747",
"0.638506",
"0.6319929",
"0.6319132",
"0.6210808",
"0.6189856",
"0.6167106",
"0.61432165",
"0.6121374",
"0.6109558",
"0.61014706",
"0.60880446",
"0.60853744",
"0.60759133",
"0.6063821... | 0.72884434 | 0 |
Returns a connection object to a MySQL database. | def create_pymysql_connection(
dbname: str, prod: bool = True, **kwargs
) -> pymysql.connections.Connection:
logger = logging.getLogger(__name__)
db_config: Dict = toolbox.open_system_config(prod=prod, config_type="DB_CONFIG")[
dbname
]
conn: pymysql.connections.Connection = None
try:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getConnection(self):\n if (not self.initialized):\n logging.error(\"Module is not initialized\")\n \n conn_options = {\n 'user': self.user,\n 'password' : self.password,\n 'host' : self.host,\n 'port' : self.port,\n 'databas... | [
"0.81339747",
"0.7922805",
"0.791989",
"0.77317",
"0.7596933",
"0.75095874",
"0.7474045",
"0.7447985",
"0.7433263",
"0.74198616",
"0.7402707",
"0.7391306",
"0.73697084",
"0.7291356",
"0.725629",
"0.7250308",
"0.71750826",
"0.7170298",
"0.71553797",
"0.7145148",
"0.7131066",
... | 0.7328943 | 13 |
Fix the dates for the CEMS data Three date/datetime changes (not all implemented) Make op_date a DATE type Make an appropriate INTERVAL type (not implemented) Add a UTC timestamp (not implemented) | def fix_up_dates(df):
# Convert to interval:
# df = convert_time_to_interval(df)
# Convert op_date and op_hour from string and integer to datetime:
# Note that doing this conversion, rather than reading the CSV with
# `parse_dates=True` is >10x faster.
# Make an operating timestamp
df["oper... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def datefixer(ds):\n\n\n\t# ========== create the new dates ==========\n\tyear = ds.Year\n\n\t# +++++ set up the list of dates +++++\n\tdates = OrderedDict()\n\ttm = [dt.datetime(int(year) , int(np.floor(tm)), int(tm%1*30+1)) for tm in ds.time]\n\tdates[\"time\"] = pd.to_datetime(tm)\n\n\tdates[\"calendar\"] = 'st... | [
"0.6125357",
"0.5819586",
"0.5773256",
"0.57689685",
"0.57060605",
"0.5502692",
"0.55019426",
"0.5471219",
"0.54283524",
"0.54059875",
"0.54014325",
"0.53956264",
"0.53769857",
"0.5311041",
"0.5306806",
"0.5298646",
"0.52898556",
"0.52759445",
"0.5245434",
"0.5235692",
"0.518... | 0.6865202 | 0 |
Reframe the CEMS hourly time as an interval NOT YET IMPLEMENTED | def convert_time_to_interval(df):
raise NotImplementedError(
"This op_interval isn't included in the " +
"SQLAlchemy model yet. Figure out what you want to do with interval " +
"data first."
)
df['op_interval'] = pd.to_datetime(
df['op_date'].str.cat(df['op_hour'].astype(str)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finish_hour(self):\n\t\tassert len(self.values) >= 4, 'A fully formed update date is needed.'\n\t\tself.values = self.values[:4]",
"def int_21H_44(self):\r\n time_now = datetime.datetime.now()\r\n\r\n hours = time_now.hour\r\n minutes = time_now.minute\r\n seconds = time_now.secon... | [
"0.5955569",
"0.5899179",
"0.586362",
"0.5832983",
"0.5738533",
"0.56580067",
"0.5656543",
"0.56431466",
"0.56165475",
"0.55842906",
"0.5531695",
"0.5522082",
"0.5517026",
"0.54948276",
"0.548903",
"0.5477767",
"0.5476642",
"0.54562736",
"0.54302275",
"0.5428698",
"0.54281735... | 0.4906633 | 84 |
Harmonize the ORISPL code to match the EIA data NOT YET IMPLEMENTED | def harmonize_eia_epa_orispl(df):
# TODO: implement this.
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, code, codeInfo):\r\n self.Code = code #IRCode\r\n self.CodeInfo = codeInfo #IRCodeInfo\r",
"def hs_code_process(si):\n hs_code = re.sub(r'\\W+', '', si.get('hs_code', ''))\n descrip = re.sub(r'\\W+', '', si.get('description_of_goods', ''))\n bl_type = re.sub(r'\\W+', '',... | [
"0.5824118",
"0.5785756",
"0.57082134",
"0.56386423",
"0.5578592",
"0.5571073",
"0.5532403",
"0.54825026",
"0.5474109",
"0.5467477",
"0.5395739",
"0.5381935",
"0.5378068",
"0.53727496",
"0.536948",
"0.53499657",
"0.5298256",
"0.5270665",
"0.52548194",
"0.52543354",
"0.5252042... | 0.55757576 | 5 |
Harmonize columns that are added later The load into Postgres checks for consistent column names, and these two columns aren't present before August 2008, so add them in. | def add_facility_id_unit_id_epa(df):
if "facility_id" not in df.columns:
df["facility_id"] = np.NaN
if "unit_id_epa" not in df.columns:
df["unit_id_epa"] = np.NaN
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _harmonize_columns(self, parse_dates=None):\n # handle non-list entries for parse_dates gracefully\n if parse_dates is True or parse_dates is None or parse_dates is False:\n parse_dates = []\n\n if not hasattr(parse_dates, '__iter__'):\n parse_dates = [parse_dates]\n\... | [
"0.66006935",
"0.6560566",
"0.6452825",
"0.621741",
"0.61326677",
"0.6062282",
"0.5985592",
"0.5894047",
"0.5881773",
"0.5863339",
"0.5851936",
"0.58452696",
"0.579159",
"0.5759374",
"0.5725462",
"0.57243407",
"0.57096153",
"0.5677327",
"0.5664387",
"0.5660616",
"0.5643589",
... | 0.0 | -1 |
Test whether every element in the series is either missing or in values This is fiddly because isin() changes behavior if the series is totally NaN (because of type issues) | def _all_na_or_values(series, values):
series_excl_na = series[series.notna()]
if not len(series_excl_na):
out = True
elif series_excl_na.isin(values).all():
out = True
else:
out = False
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nan_value(data):\n return data.isnull().any()",
"def is_empty(series):\n return series.isna().all()",
"def checkNaN(data):\n if data.isnull().values.any():\n N = data.isnull().sum().sum()\n print(\"There are {} missing values.\".format(N))",
"def pd_isnan(val):\n return val is N... | [
"0.6702152",
"0.65366334",
"0.64191544",
"0.6405477",
"0.6321939",
"0.63141245",
"0.61905783",
"0.6163543",
"0.61403567",
"0.6065991",
"0.60013145",
"0.59662825",
"0.592186",
"0.5896812",
"0.5895072",
"0.58945686",
"0.5826522",
"0.5777309",
"0.57611376",
"0.57524323",
"0.5752... | 0.73976064 | 0 |
Drop these calculated rates because they don't provide any information. If you want these, you can just use a view. | def drop_calculated_rates(df):
if not _all_na_or_values(df["so2_rate_measure_flg"], {"Calculated"}):
raise AssertionError()
if not _all_na_or_values(df["co2_rate_measure_flg"], {"Calculated"}):
raise AssertionError()
del df["so2_rate_measure_flg"], df["so2_rate_lbs_mmbtu"]
del df["co2_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rates(self):\n return self._rates",
"def rates(self):\n raise NotImplementedError(\"Must be implemented by subclass.\")",
"def get_zero_rates(self):\r\n self.__bootstrap_zero_coupons__()\r\n self.__get_bond_spot_rates__()\r\n return [self.zero_rates[T] for T in self.get_matur... | [
"0.61796653",
"0.6036099",
"0.5962428",
"0.57073414",
"0.565551",
"0.5630784",
"0.56072664",
"0.5545332",
"0.55377626",
"0.5521308",
"0.5488782",
"0.5419411",
"0.5387603",
"0.5350166",
"0.53407055",
"0.53198713",
"0.5319001",
"0.52960646",
"0.52811706",
"0.5280485",
"0.526765... | 0.635766 | 0 |
Transform EPA CEMS hourly | def transform(epacems_raw_dfs, verbose=True):
if verbose:
print("Transforming tables from EPA CEMS:")
# epacems_raw_dfs is a generator. Pull out one dataframe, run it through
# a transformation pipeline, and yield it back as another generator.
for raw_df_dict in epacems_raw_dfs:
# There'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_apc(self, day):\n pass",
"def OPCtimetransform(data, to):\n \n remove_times = []\n outtimes = []\n times = {'ms':[],'SS':[],'MM':[],'HH':[]}\n\n for i in range(0, len(data)):\n times['HH'] = 0\n times['MM'] = 0\n times['SS'] = 0\n times['ms'] = 0\n... | [
"0.60664696",
"0.5939547",
"0.5908493",
"0.5785593",
"0.56355613",
"0.55279034",
"0.54089785",
"0.5343298",
"0.53368235",
"0.53047395",
"0.52986807",
"0.52903795",
"0.5272429",
"0.5263401",
"0.5250048",
"0.52491313",
"0.5201047",
"0.519941",
"0.51899326",
"0.51883954",
"0.518... | 0.0 | -1 |
Run the detection algorithm | def run(self):
# Define our components entry point
while True:
# for each packet waiting on our input port
for packet in self.receive_all('in'):
try:
image = packet.get("data")
log.debug("%s received %s %s",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_image(self):\n\n detect.main(self.nn_args)",
"def run(self):\n while True:\n ret, frame = self.classification()\n # valid frame\n if ret == True:\n # output the recognized face\n if self.video_out != None:\n ... | [
"0.77328193",
"0.7268141",
"0.7214604",
"0.71461743",
"0.69773424",
"0.6935214",
"0.6867518",
"0.68465203",
"0.6806285",
"0.6805328",
"0.67979944",
"0.67744297",
"0.6743964",
"0.6728882",
"0.67030495",
"0.66178083",
"0.6602134",
"0.65822536",
"0.65799975",
"0.6565747",
"0.654... | 0.0 | -1 |
Calculates the bins used in the Riemann sum over metallicities | def calculateMetallicityBinEdges(self):
if self.binInLogSpace:
logMetallicities = np.log10(self.metallicityGrid)
b= logMetallicities[:-1] + (logMetallicities[1:] - logMetallicities[:-1])/2.
b = 10.**b #the boundaries for integration are not in log space so
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_energy_bins(image, num_bins=4):\r\n h, _ = image.shape\r\n C = np.linspace(0, h//2, num=num_bins+1, dtype=\"int\")\r\n # Create a list of dense square mask\r\n mask_list = [square_mask(image, c) for c in C[1:]]\r\n # Extract a list of hollow mask\r\n square_zones = [~mask_list[k]*mask_lis... | [
"0.63174194",
"0.6299061",
"0.62940705",
"0.6222577",
"0.6208876",
"0.6017929",
"0.598964",
"0.59230375",
"0.59167486",
"0.58886397",
"0.58843166",
"0.5880696",
"0.58755875",
"0.58755875",
"0.58666515",
"0.5855976",
"0.58558095",
"0.584502",
"0.5839998",
"0.5780967",
"0.57703... | 0.6595891 | 0 |
This function translates between logOH12 = number density of oxygen to hyrdogen logZZsun = metallicity mass fraction in solar units | def LogOH12vsLogZZsun(self, value, inValue='logOH12'):
if (inValue == 'logZZsun'):
#translate from logZZsun to logOH12
logOH12 = value + self.logOH12sun
return logOH12
elif (inValue == 'logOH12'):
#translate from logOH12 to logZZsun
logZZsun = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def linear_to_mel(frequency):\n return 1127.01048 * np.log(1.0 + frequency / 700.0)",
"def hertz_to_mel(freq):\n return 2595.0 * np.log10(1 + (freq / 700.0))",
"def hertz_to_mel(self, freq):\n return 3340.0 * log(1 + (freq / 250.0), 9)",
"def hz2mel(hz):\r\n return 2595 * np.log10(1+hz/700.0)... | [
"0.64378303",
"0.63970214",
"0.6097403",
"0.60859525",
"0.6012672",
"0.59911144",
"0.5966454",
"0.59580696",
"0.586378",
"0.5845092",
"0.58260393",
"0.5823959",
"0.57857716",
"0.5778106",
"0.5675272",
"0.56143516",
"0.5612323",
"0.55670613",
"0.55585444",
"0.5534007",
"0.5533... | 0.5505402 | 22 |
Returns the fraction of the SFR. It combines a | def returnFractionMZ_GSMF(self, Zlower, Zupper, redshift):
z = np.copy(redshift) #found that the mask z>4 overwrites input
#these prescriptions work in metallicities of unit solar
Zupper_Zsun = Zupper/ self.solarMetallicity
Zlower_Zsun = Zlower/ self.solarMetallicity
#Not com... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getfloat(self, fraction) -> float:\n self.numerator_a = fraction.numerator_a\n self.denominator_b = fraction.denominator_b\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\n return super().__float__()",
"def __float__(self) -> float:\n float_number = ... | [
"0.6898648",
"0.6879199",
"0.6687929",
"0.6375416",
"0.6367122",
"0.63262564",
"0.6292171",
"0.6285895",
"0.62443894",
"0.6208853",
"0.6184171",
"0.61787236",
"0.6174918",
"0.616172",
"0.6159846",
"0.61596227",
"0.61131597",
"0.611027",
"0.61037",
"0.6078617",
"0.6074802",
... | 0.0 | -1 |
fingerspitzengefuhl Cosmic integration paper | def SFR_Neijssel(self, z):
SFR = 0.01 * ((1+z)**2.77) / (1 + ((1+z)/2.9)**4.7) * 1e9 #[1e9 for GPc-3]
return SFR # [Msun yr-1 Gpc-3] in comoving volume | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def psi_enstrophy(\n Tau, # SGS; (6,64,64,64)\n h = False, # spatial step size\n flag = True): # spectral flag; default is gradient tool\n #---------------------------------------------------------------------#\n # Default variables ... | [
"0.6248479",
"0.6207774",
"0.61614895",
"0.6117317",
"0.61117685",
"0.6110506",
"0.6109973",
"0.6097946",
"0.608143",
"0.6043247",
"0.603947",
"0.60337144",
"0.59739536",
"0.59240717",
"0.59205556",
"0.5892042",
"0.5879855",
"0.58760244",
"0.58726484",
"0.5853395",
"0.5852051... | 0.0 | -1 |
Custom SFR same functional form as Madau et al | def SFR_Custom(self, z):
a = self.customSFR[0]
b = self.customSFR[1]
c = self.customSFR[2]
d = self.customSFR[3]
SFR = a * ((1+z)**b) / (1 + ((1+z)/c)**d) * 1e9 #[1e9 for GPc-3]
return SFR # [Msun yr-1 Gpc-3] in comoving volume | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def falcon():",
"def _regr_basic():",
"def smethod(fx,L=11,nh=2**8,tstep=2**7,ng=1,df=1.0,nfbins=2**10,sigmaL=None):\r\n \t\r\n df=float(df)\r\n \r\n if type(fx) is list:\r\n fx=np.array(fx)\r\n try:\r\n fn,fm=fx.shape\r\n if fm>fn:\r\n fm,fn=fx.shape\r\n excep... | [
"0.658998",
"0.5861054",
"0.582489",
"0.56668854",
"0.5608356",
"0.5601948",
"0.5588368",
"0.5558229",
"0.5507446",
"0.5393739",
"0.53269464",
"0.5320055",
"0.5313944",
"0.5293867",
"0.5290645",
"0.5257212",
"0.5254912",
"0.52474356",
"0.5243596",
"0.52326226",
"0.5229233",
... | 0.55980986 | 6 |
Instead of combining a GSMF and MZ relation you can also directly construct a redshift dependent metallicity distribution In this case we focus on a lognormal distribution | def returnFractionLogNormal(self, Zlower, Zupper, redshift):
if self.logNormalPrescription == 'Neijssel Phenomenological':
"Based on norman Langer"
Z0 = 0.035
alpha = -0.23
sigma = 0.39
elif self.logNormalPrescription == 'Custom Phenomenologica... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_metallicity_distribution(redshifts, min_logZ_COMPAS, max_logZ_COMPAS,\n mu0=0.035, muz=-0.23, sigma_0=0.39, sigma_z=0.0, alpha =0.0,\n min_logZ =-12.0, max_logZ =0.0, step_logZ = 0.01): \n ##################################\n # Log-... | [
"0.7099358",
"0.6048183",
"0.601982",
"0.5922323",
"0.58795625",
"0.58391565",
"0.58315736",
"0.57944214",
"0.5784503",
"0.57521254",
"0.5725489",
"0.57061166",
"0.57040393",
"0.56882674",
"0.5648836",
"0.56422466",
"0.5573206",
"0.5572834",
"0.55553544",
"0.55145085",
"0.549... | 0.5417146 | 31 |
This is the main function called in the cosmic integration routine. For a given binNr in the metallicity bins it calculates the MSSFR | def returnMSSFR(self, metallicity=None, agesBirth=None, redshiftBirth=None):
# find the bin number
lowerBinNr = np.where(self.metallicityGrid == metallicity)[0][0]
#we will only calculate the systems of which ages
# and redshifts are not -1 (flagged as born too soon)
mask =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SFSchmidt10(jd,mag,errmag,nbin=0.1,bmin=5,bmax=2000):\n\n dtarray, dmagarray, sigmaarray = SFarray(jd,mag,errmag)\n ndt=np.where((dtarray<=365))\n dtarray=dtarray[ndt]\n dmagarray=dmagarray[ndt]\n sigmaarray=sigmaarray[ndt]\n\n bins=bincalc(nbin,bmin,bmax)\n #print(len(bins))\n\n\n sf_l... | [
"0.65696776",
"0.6289473",
"0.62524277",
"0.60693973",
"0.6062215",
"0.58293533",
"0.58011806",
"0.579511",
"0.57943225",
"0.57800806",
"0.576732",
"0.5765215",
"0.5763416",
"0.5738214",
"0.57146233",
"0.5697235",
"0.56917053",
"0.5680746",
"0.56798327",
"0.56759155",
"0.5640... | 0.5302065 | 75 |
exercise new directory revert facility | def test_revert_2(self):
self.image_create(self.rurl)
some_files = ["etc/A", "etc/B", "etc/C"]
# first try reverting tag that doesn't exist
self.pkg("install A@1.1 W@1")
self.pkg("verify")
self.pkg("revert --tagged alice", ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_revert_3(self):\n self.image_create(self.rurl)\n some_files = [\"dev/xxx\", \"dev/yyy\", \"dev/zzz\",\n \"dev/dir1/aaaa\", \"dev/dir1/bbbb\", \"dev/dir2/cccc\",\n \"dev/cfg/ffff\", \"dev/cfg/gggg\",\n ... | [
"0.67572284",
"0.66160476",
"0.62285644",
"0.61401373",
"0.6042075",
"0.6004498",
"0.59423554",
"0.59241223",
"0.5858682",
"0.5839227",
"0.58292013",
"0.5827911",
"0.5822132",
"0.5730254",
"0.5710568",
"0.570762",
"0.5701192",
"0.566655",
"0.5651539",
"0.5626604",
"0.56164724... | 0.60886854 | 4 |
duplicate usage in /dev as per Ethan's mail | def test_revert_3(self):
self.image_create(self.rurl)
some_files = ["dev/xxx", "dev/yyy", "dev/zzz",
"dev/dir1/aaaa", "dev/dir1/bbbb", "dev/dir2/cccc",
"dev/cfg/ffff", "dev/cfg/gggg",
"dev/cfg/dir3/... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def usage(self, host):",
"def showUsage():\n None",
"def usage():",
"def usage():",
"def usage():\n return _usage",
"def test_create_same_devices(self):\n command_line = self._MENU + [self._POOLNAME] + self.devices\n self.check_error(StratisCliNameConflictError, command_line, _ERROR)",
... | [
"0.59579253",
"0.53823954",
"0.5255355",
"0.5255355",
"0.5218427",
"0.5217153",
"0.5188536",
"0.5177703",
"0.5168382",
"0.51058227",
"0.5101718",
"0.5089739",
"0.5030349",
"0.50100166",
"0.50020605",
"0.4969143",
"0.49685776",
"0.49660528",
"0.49582165",
"0.49555704",
"0.4955... | 0.0 | -1 |
Make component fields, other info into dict for template context | def make_context(
container: ServiceContainer,
component_name: str,
**kwargs
) -> Dict[str, Any]:
from wired_components.component import IWrapComponents, IComponent
# Start with all the wrapped components
context: Dict[str, Any] = container.get(IWrapComponents)
# We get the co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _template_data(self):\n return {\"form\": self.form.render()}",
"def _get_render_context(self):\r\n context = {\r\n 'id': self.input_id,\r\n 'value': self.value,\r\n 'status': Status(self.status, self.capa_system.i18n.ugettext),\r\n 'msg': self.msg,\r... | [
"0.65645075",
"0.6080614",
"0.5978665",
"0.58917844",
"0.5774367",
"0.5748968",
"0.57399213",
"0.57305616",
"0.56950396",
"0.5634534",
"0.55968183",
"0.55514616",
"0.5549723",
"0.5531995",
"0.550397",
"0.54978746",
"0.5492822",
"0.5489106",
"0.54887336",
"0.54638904",
"0.5444... | 0.6259585 | 1 |
c0 = coords_cut[i] cc0 = c0.cartesian xc, yc, zc = cc0.x.value, cc0.y.value, cc0.z.value x0, y0, d0 = c0.ra.value, c0.dec.value, c0.distance.value ang_max = 180. (sep / d0) / np.pi in_z = (np.absolute(coords.distance.value d0) 1e10]x[np.abs(nr)>1e10]/nr[np.abs(nr)>1e10]), \ np.sum(M[np.abs(nr)>1e10]y[np.abs(nr)>1e10]/n... | def pvector_pp(i, q):
c0 = coords_cut[i]
ra, dec = c0.ra.value, c0.dec.value
r = hp.rotator.Rotator([ra, dec, 0])
sT = np.matmul(r.mat, np.matmul(s_tensor_cut[:,:,i], r.mat.transpose()))
evals, evecs = np.linalg.eigh(sT[1:,1:])
evecA, evecB = evecs[:,0], evecs[:,1]
if evecB[0] < 0:
evecB = -evecB
theta = np.a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def at_b (self):\n self.argc = int((len(n.coord[0]))/2)\n self.pts_con = np.array(self.coord[:,self.argc:len(n.coord[0])])\n\n self.xd = self.xdi\n self.zd = self.zdi \n \n for i, x in enumerate(self.xdi):\n self.aux_con = self.pts_con[0] - x ... | [
"0.6363257",
"0.60241544",
"0.5992478",
"0.5950258",
"0.5903262",
"0.5798193",
"0.57892615",
"0.578824",
"0.57877165",
"0.5726131",
"0.5708826",
"0.56843597",
"0.5664259",
"0.5659503",
"0.56462854",
"0.56304055",
"0.5615204",
"0.5607706",
"0.5607545",
"0.55574065",
"0.5549847... | 0.5524634 | 21 |
Takes the state code and creates output file for the state | def prep_prov_data(state='CT'):
# Read the POS file
file = f"{data_path}\pos_other_Dec20.csv"
df = pd.read_csv(file, encoding='cp1252')
df = df[['PRVDR_NUM', 'ST_ADR', 'CITY_NAME', 'STATE_CD', 'ZIP_CD','FIPS_CNTY_CD', 'CBSA_URBN_RRL_IND']]
print(f'Original dataframe has {df.shape[0]} rows')
# F... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_state_file(self, state):\r\n with open(StudentModuleHistoryCleaner.STATE_FILE, \"w\") as state_file:\r\n state_file.write(state)",
"def genStatesCode(self):\n for s, d in self.info['machine'].items():\n transition_code_arr = []\n for t in self.info['transi... | [
"0.6710576",
"0.6646066",
"0.6246326",
"0.61974907",
"0.619098",
"0.61461467",
"0.6093751",
"0.6014258",
"0.5977046",
"0.5960007",
"0.5928979",
"0.58888406",
"0.5832172",
"0.5800238",
"0.57619494",
"0.5753456",
"0.57476705",
"0.56991893",
"0.5686789",
"0.5676803",
"0.5664246"... | 0.0 | -1 |
Launch training of the model with a set of hyperparameters in parent_dir/job_name | def launch_training_job(model_dir,job_name, params, implementation_dir):
# Create a new folder in implementation corresponding to the model
implementation_dir = os.path.join(implementation_dir, os.path.basename(os.path.normpath(model_dir)))
if not os.path.exists(implementation_dir):
os.makedirs(impl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def launch_training_job(parent_dir, data_dir, job_name, params):\n # Create a new folder in parent_dir with unique_name \"job_name\"\n model_dir = os.path.join(parent_dir, job_name)\n if not os.path.exists(model_dir):\n os.makedirs(model_dir)\n\n # Write parameters in json file\n json_path = ... | [
"0.80069077",
"0.7198703",
"0.71838933",
"0.6437247",
"0.63805366",
"0.629484",
"0.62795806",
"0.6278729",
"0.62004155",
"0.6189536",
"0.6156923",
"0.6135809",
"0.61020046",
"0.6097955",
"0.60901624",
"0.60863006",
"0.60771877",
"0.6063894",
"0.6054576",
"0.6025766",
"0.60214... | 0.7579028 | 1 |
Takes a positive list of integers along with a target and returns a subset of | def diophantine_subset_sum(number_list, target, time_limit=TIME_LIMIT):
started_at = time.time()
# Sort numbers list.
number_list = sorted(number_list)
# Build sums list.
sums_list = [number_list[0]]
for n in range(1, len(number_list)):
sums_list.append(number_list[n] + sums_list[n-1])... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _select_sublist(lst, target):\n ln = len(lst)\n\n # Generate an array that indicates the decision bit for each element in the list.\n # If an element is deterministically true, then no decision bit is needed.\n choice_bits = [None] * ln\n x = 0\n for i in range(0, ln):\n if lst[i][1] n... | [
"0.7094783",
"0.65067834",
"0.6460729",
"0.63038445",
"0.6270336",
"0.62450624",
"0.62270397",
"0.61682236",
"0.61059326",
"0.6029637",
"0.6015087",
"0.5967162",
"0.5875812",
"0.5808211",
"0.5807387",
"0.57974637",
"0.5757506",
"0.5754575",
"0.5735689",
"0.5707086",
"0.569802... | 0.693455 | 1 |
Here select interesting offers to notify in tg in where defined additional filters, for example, distance from center less than 30 km and defined period for which offers were created | async def extract_data_to_notify(app):
notification_data = await app.db.select(
f"""
SELECT added_timestamp,
total_area,
full_url,
jk_url,
nearest_underground,
nearest_underground_dist,
price_rur, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_offers_to_send(self) -> Dict[Tuple[float, float], float]:\n partial_asgt = self._neighbors_values.copy()\n offers = dict()\n\n for limited_asgt in generate_assignment_as_dict([self.variable, self._partner]):\n partial_asgt.update(limited_asgt)\n cost = self._... | [
"0.5478844",
"0.54343915",
"0.5411153",
"0.52321213",
"0.5225025",
"0.51286703",
"0.51178557",
"0.50775",
"0.5036253",
"0.5035772",
"0.503197",
"0.50226885",
"0.5009665",
"0.5009194",
"0.49829316",
"0.49653837",
"0.49478367",
"0.49094522",
"0.49093115",
"0.4901606",
"0.488506... | 0.0 | -1 |
Convert unit with default UnitRegistry (i.e, application_registry) | def test_convert_unit_with_pint(test_df, current, to):
df = get_units_test_df(test_df)
# replace EJ/yr by EJ to test pint with single unit
if current == "EJ":
df.rename(unit={"EJ/yr": "EJ"}, inplace=True)
exp = pd.Series([1.0, 6.0, 138.88, 833.33, 555.55, 1944.44], name="value")
assert_con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _convert_unit(self, unit):\n if unit in self.units:\n return self.units[unit]\n elif unit in unit_map:\n return unit_map[unit]\n else:\n raise SBMLError('Unit not recognized: ' + str(unit))",
"def test_convert_unit_with_custom_registry(test_df):\n df = ... | [
"0.687325",
"0.684293",
"0.66271764",
"0.6505694",
"0.6295247",
"0.6124371",
"0.5856852",
"0.58415043",
"0.58247006",
"0.5799204",
"0.57857335",
"0.5764567",
"0.5676909",
"0.56088245",
"0.5580017",
"0.5564396",
"0.55641305",
"0.55638456",
"0.5550743",
"0.55411625",
"0.5519221... | 0.0 | -1 |
Convert unit with definition loaded from `IAMconsortium/units` repo | def test_convert_unit_from_repo(test_df):
df = get_units_test_df(test_df)
exp = pd.Series([1.0, 6.0, 17.06, 102.361, 68.241, 238.843], name="value")
assert_converted_units(df, "EJ/yr", "Mtce/yr", exp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _convert_unit(self, unit):\n if unit in self.units:\n return self.units[unit]\n elif unit in unit_map:\n return unit_map[unit]\n else:\n raise SBMLError('Unit not recognized: ' + str(unit))",
"def _get_units_object(self, units):\n if isinstance(unit... | [
"0.73016477",
"0.6947638",
"0.69390184",
"0.69115627",
"0.69105035",
"0.6857282",
"0.6822706",
"0.6779308",
"0.66278255",
"0.6605075",
"0.6557178",
"0.65434927",
"0.6530906",
"0.6432699",
"0.6416121",
"0.6377947",
"0.6370534",
"0.6358671",
"0.63333696",
"0.63289326",
"0.63137... | 0.643053 | 14 |
Convert unit conversion with custom UnitRegistry | def test_convert_unit_with_custom_registry(test_df):
df = get_units_test_df(test_df).rename(unit={"EJ/yr": "foo"})
# check that conversion fails with application registry
with pytest.raises(pint.UndefinedUnitError):
df.convert_unit("foo", "baz")
# define a custom unit registry
ureg = pint.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _convert_unit(self, unit):\n if unit in self.units:\n return self.units[unit]\n elif unit in unit_map:\n return unit_map[unit]\n else:\n raise SBMLError('Unit not recognized: ' + str(unit))",
"def convertUnit(*args, fromUnit: AnyStr=\"\", toUnit: AnyStr=\"... | [
"0.72558576",
"0.7242834",
"0.69972605",
"0.67883354",
"0.6740144",
"0.6727505",
"0.6723467",
"0.67014116",
"0.66655236",
"0.6658775",
"0.6603207",
"0.65299666",
"0.64555025",
"0.64369696",
"0.6419799",
"0.64174867",
"0.64120305",
"0.6399249",
"0.63895",
"0.6342039",
"0.63326... | 0.72553796 | 1 |
Units and GHG species can be converted. | def test_convert_gwp(
test_df, context, current_species, current_expr, to_expr, exp, exp_factor
):
# Handle parameters
current = current_expr.format(current_species)
to = to_expr.format("CO2e")
# Expected values
exp_values = test_df._data.copy()
exp_values[[False, False, True, True, True, T... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_to(self, units: str) -> None:\n if self.units == units:\n return\n\n if units not in Variable.VALID_UNIT_CONVERSIONS[self.units]:\n msg = f\"\"\"Not a valid unit conversion. Valid destination units:\n {Variable.VALID_UNIT_CONVERSIONS[self.units]}\"\"\"\n ... | [
"0.57525384",
"0.57275754",
"0.5674095",
"0.5629548",
"0.5565156",
"0.55589813",
"0.5499987",
"0.5466268",
"0.54491645",
"0.5431514",
"0.5431423",
"0.54084706",
"0.54083174",
"0.5377826",
"0.5314006",
"0.5296716",
"0.5266335",
"0.5263386",
"0.52353054",
"0.5214933",
"0.521232... | 0.49707523 | 59 |
Unit conversion with bad arguments raises errors. | def test_convert_unit_bad_args(test_pd_df):
idf = IamDataFrame(test_pd_df).rename(unit={"EJ/yr": "Mt CH4"})
# Conversion fails with both *factor* and *registry*
with pytest.raises(ValueError, match="Use either `factor` or `registry`!"):
idf.convert_unit("Mt CH4", "CO2e", factor=1.0, registry=object... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convertUnit(*args, fromUnit: AnyStr=\"\", toUnit: AnyStr=\"\", **kwargs)->float:\n pass",
"def test_convert_invalid_unit():\n with pytest.raises(ValueError):\n pressure_util.convert(5, INVALID_SYMBOL, VALID_SYMBOL)\n\n with pytest.raises(ValueError):\n pressure_util.convert(5, VALID_SY... | [
"0.80642945",
"0.76356244",
"0.7445948",
"0.7313819",
"0.7179943",
"0.68142354",
"0.6702233",
"0.67012995",
"0.648865",
"0.64848894",
"0.637458",
"0.63654095",
"0.63062716",
"0.63011336",
"0.6265371",
"0.6258366",
"0.62375414",
"0.6222837",
"0.61793447",
"0.6161228",
"0.61586... | 0.7108532 | 5 |
Convert units with custom factors. | def test_convert_unit_with_custom_factor(test_df):
# unit conversion with custom factor
df = get_units_test_df(test_df)
exp = pd.Series([1.0, 6.0, 1.0, 6.0, 4.0, 14.0], name="value")
assert_converted_units(df, "EJ/yr", "foo", exp, factor=2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6",
"def convert_units(data, units):\n # Build the dictionary of units conversions\n convert = {'m' : [1.0, 0., 'm'], \n 'meter' : [1.0, 0., 'm'], \n 'deg C' : [1... | [
"0.7592755",
"0.7377087",
"0.7234802",
"0.72110605",
"0.7108356",
"0.71072423",
"0.70839715",
"0.6940497",
"0.6894842",
"0.68894947",
"0.6876686",
"0.68304235",
"0.6814569",
"0.67865115",
"0.67414594",
"0.67141014",
"0.6706773",
"0.66971725",
"0.6690622",
"0.6680311",
"0.6671... | 0.72322226 | 3 |
Convert this object into a dictionary. | def to_dict(self) -> dict:
return dict(sentences=[sentence.to_dict() for sentence in self.sentences]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_dict(self):\n return asdict(self)",
"def to_obj(self):\n return dict()",
"def to_dict(self):\n return to_dict(self.__dict__)",
"def asdict(self) -> dict:\n return self.__asdict(self)",
"def to_dict(self):\n return dict(self)",
"def _to_dict(self):\n return... | [
"0.8573397",
"0.8572996",
"0.8508446",
"0.8472537",
"0.8470109",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"0.8465864",
"... | 0.0 | -1 |
Convert this object into a string. | def to_string(self) -> str:
return f"<Document, #sentences: {len(self.sentences)}>" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_string(self):\r\n return self.__str__()",
"def serialize(self):\n\n return str(self)",
"def serialize(self):\n\n\t\treturn str(self)",
"def __str__(self):\n return str(self.serialize())",
"def to_str(self) -> str:",
"def __str__(self):\n return bytes_to_str(bytes(self))... | [
"0.8671065",
"0.8303624",
"0.8287494",
"0.8237525",
"0.8199979",
"0.8178291",
"0.8064898",
"0.8064313",
"0.80085224",
"0.80085224",
"0.8003638",
"0.79904777",
"0.7987857",
"0.7974399",
"0.7922337",
"0.7922337",
"0.7921466",
"0.7921466",
"0.7921466",
"0.79149413",
"0.78538585"... | 0.0 | -1 |
insert a column to tb. if called, all operation related to db must be fitted. | def insert_column(self, tb_name, column_name, data_type):
sentences = f"""
ALTER TABLE {tb_name} ADD COLUMN {column_name} {data_type};
"""
print(sentences)
self.commit(sentences) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _addColumn(self, table, column, init_data):\n\t\tcommand = \"ALTER TABLE \" + table + \" ADD COLUMN \" + str(column) + \" \" + getSQLiteType(init_data)\n\t\ttry:\n\t\t\tself._run_command(command)\n\t\texcept sqlite3.OperationalError:\n\t\t\tprint(\"Column \" + str(column) + \" already exists!\")",
"def inser... | [
"0.6773",
"0.65841776",
"0.64992654",
"0.6474949",
"0.6455139",
"0.64373386",
"0.6368149",
"0.6303153",
"0.629054",
"0.6239281",
"0.6229999",
"0.622003",
"0.6205193",
"0.6202118",
"0.6199418",
"0.6196598",
"0.6169299",
"0.6163966",
"0.613079",
"0.60933846",
"0.60929984",
"0... | 0.76917046 | 0 |
Get values for keys | def mget(self, keys: List[K]) -> List[Optional[V]]:
raise NotImplementedError('mget must be reimplemented in concrete implementation') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_key_values(self):\n return self.key_values",
"def values(self):\n with self.__plock:\n return map(self.get, self._keys)",
"def values(self):\n return [self[k] for k in self.keys()]",
"def values(self):\n return [self[key] for key in self.keys()]",
"def values(... | [
"0.78560966",
"0.7809564",
"0.7629101",
"0.76030433",
"0.76030433",
"0.76030433",
"0.75565445",
"0.7534844",
"0.75304735",
"0.7513847",
"0.74225706",
"0.73467046",
"0.72960025",
"0.7254402",
"0.7246637",
"0.71887136",
"0.70794696",
"0.7065934",
"0.6987683",
"0.69494283",
"0.6... | 0.62629557 | 82 |
Get a single key | def get(self, key: K) -> Optional[V]:
return self.mget([key])[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_key(self):\n return self._determine_key()",
"def key(key):\n return key",
"def get(self, key):\n result = self.search({\n \"field\": \"identity.key\",\n \"operator\": \"=\",\n \"value\": key})\n if len(result) > 1:\n raise Sarasvat... | [
"0.74487877",
"0.7393895",
"0.73517627",
"0.7345837",
"0.7345837",
"0.7293161",
"0.7262227",
"0.7217249",
"0.71878386",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
"0.7176885",
... | 0.0 | -1 |
Get values for keys | def mset(self, kvs: Mapping[K, V]) -> List[bool]:
raise NotImplementedError('mset must be reimplemented in concrete implementation') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_key_values(self):\n return self.key_values",
"def values(self):\n with self.__plock:\n return map(self.get, self._keys)",
"def values(self):\n return [self[k] for k in self.keys()]",
"def values(self):\n return [self[key] for key in self.keys()]",
"def values(... | [
"0.78560966",
"0.7809564",
"0.7629101",
"0.76030433",
"0.76030433",
"0.76030433",
"0.75565445",
"0.7534844",
"0.75304735",
"0.7513847",
"0.74225706",
"0.73467046",
"0.72960025",
"0.7254402",
"0.7246637",
"0.71887136",
"0.70794696",
"0.7065934",
"0.6987683",
"0.69494283",
"0.6... | 0.0 | -1 |
Remove list of keys from the store | def delete(self, keys: List[K]) -> List[bool]:
raise NotImplementedError('delete must be reimplemented in concrete implementation') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def removeAllKeys(self) -> None:\n ...",
"def delete_many(self, keys):\n raise NotImplementedError()",
"def rem(self, keys: Union[str, Iterable]):\n return(self.db.delVal(db=self.sdb, key=self._tokey(keys)))",
"def rem(self, keys: Union[str, Iterable]):\n return(self.db.delVal(db=... | [
"0.7374732",
"0.7209796",
"0.68456185",
"0.68456185",
"0.68456185",
"0.684242",
"0.6835356",
"0.6829273",
"0.6737269",
"0.6679472",
"0.66645175",
"0.6656001",
"0.6648994",
"0.66087186",
"0.6540633",
"0.6525455",
"0.6507897",
"0.6493868",
"0.6461113",
"0.6430038",
"0.6426386",... | 0.6642458 | 13 |
Clear the whole store | def clear(self) -> bool:
raise NotImplementedError('clear must be reimplemented in concrete implementation') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self) -> None:\n self._store.clear()",
"def clear(self):\n self._store = {}",
"def clearStore(self):\n os.remove(self.uid+\".pcl\")\n self.items = []",
"def clear(self):\n self.tensor_store.clear()\n self.i = 0",
"def clear(self):\n self._storage.c... | [
"0.86360115",
"0.8251459",
"0.8168097",
"0.76454467",
"0.754934",
"0.7438981",
"0.7416115",
"0.7318606",
"0.7248102",
"0.7210689",
"0.7210689",
"0.7209975",
"0.7209975",
"0.7209975",
"0.7167617",
"0.71544695",
"0.714768",
"0.71438867",
"0.7102816",
"0.71001446",
"0.70647645",... | 0.0 | -1 |
Get a bunch of keys either from the cache layer or from the base | def mget(self, keys: List[K]) -> List[Optional[V]]:
# Note an explicit check for None, because falsy values can be valid keys
valid_index_and_key_list = [(idx, key) for idx, key in enumerate(keys) if key is not None]
# Initialize the results
results = [None] * len(keys)
if valid... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _multi_get(self, keys, encoding=\"utf-8\"):\n return [SimpleMemoryBackend._cache.get(key) for key in keys]",
"def keys_fetch(self):\n with self.env.begin(write=False) as txn:\n cursor = txn.cursor()\n tot = txn.stat()['entries']\n i = 0\n\n path... | [
"0.6834069",
"0.6382025",
"0.6335966",
"0.62565744",
"0.624546",
"0.6219669",
"0.6212312",
"0.61953014",
"0.61886495",
"0.61742663",
"0.6109253",
"0.60742164",
"0.6064275",
"0.60528266",
"0.6002826",
"0.5956592",
"0.59504443",
"0.59299576",
"0.58935183",
"0.58931494",
"0.5884... | 0.6371455 | 2 |
Get value for the key | def get(self, key: K)-> Optional[V]:
return self._func(key) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_value(self, key):\n pass",
"def get_value(self, key):\n return self[key]",
"def get_value(self, key):\n return self.data.get(key)",
"def get_value(self, key):\n return self[key]['value']",
"def get( self, key ):\n if key not in self._values:\n raise Val... | [
"0.8878386",
"0.88521105",
"0.86971056",
"0.8678441",
"0.829813",
"0.8179047",
"0.8178329",
"0.8177001",
"0.8166392",
"0.8132502",
"0.8081488",
"0.80803794",
"0.8015064",
"0.7961579",
"0.7961579",
"0.78647137",
"0.78497577",
"0.78319174",
"0.77768177",
"0.7714798",
"0.7693951... | 0.0 | -1 |
Verifies that the appears in page title | def is_title_matches(self):
return "EXNESS - Trader Calculator and Currency Converter" in self.driver.title | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_title(self):\n currenttitle = self.driver.title\n assert self.TITLE in currenttitle, 'Title not expected. Actual: ' + currenttitle + ', Expected: ' + self.TITLE",
"def verifyPageTitle(self, titleToVerify):\n try:\n actualTitle = self.getTitle()\n return self.u... | [
"0.7973157",
"0.7904546",
"0.7394582",
"0.73098224",
"0.71877354",
"0.71312666",
"0.71010184",
"0.7058365",
"0.696883",
"0.6958025",
"0.6924629",
"0.69108593",
"0.68864435",
"0.68840015",
"0.6877334",
"0.68517303",
"0.6819171",
"0.6722788",
"0.6661423",
"0.66260976",
"0.66160... | 0.66116136 | 21 |
Draw something into the buffer | def draw_tiles(self):
db = self.double_buffer
if db is not None:
span_x = self.width
span_y = self.height
tiles_x = int(ceil(span_x/256.0))
tiles_y = int(ceil(span_y/256.0))
cc = cairo.Context(db)
tiles = self.tile_loader.load_area... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw():",
"def draw(self, screen):",
"def draw(self):\n pass",
"def draw(self):\n pass",
"def draw(self):\n pass",
"def draw(self):\n pass",
"def draw(self):\n\t\tpass",
"def draw(self):",
"def draw(self):\n self.batch.draw()",
"def draw(self):\n rais... | [
"0.82649606",
"0.7830266",
"0.76652217",
"0.76652217",
"0.76652217",
"0.76652217",
"0.7653738",
"0.75657344",
"0.74521",
"0.735082",
"0.735082",
"0.735082",
"0.7295304",
"0.72623223",
"0.7143406",
"0.7132452",
"0.71102107",
"0.70918834",
"0.7013929",
"0.6921154",
"0.69120276"... | 0.0 | -1 |
Throw double buffer into widget drawable | def on_draw(self, widget, cr):
#print "starting to draw"
if self.double_buffer is not None:
self.draw_tiles()
cr.set_source_surface(self.double_buffer, 0.0, 0.0)
cr.paint()
else:
print('Invalid double buffer')
#print "done drawing"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_buffer(self):\n \n self.shape.buf = [pi3d.Buffer(self.shape, self.verts, self.texcoords, self.inds, self.norms)]\n self.shape.set_draw_details(self.shader, [self.spritesheet.img])",
"def draw(self):",
"def draw(self, screen):",
"def pre_draw(self):",
"def on_configure(self, wi... | [
"0.5492979",
"0.54373515",
"0.541417",
"0.5406553",
"0.53597254",
"0.5355659",
"0.5354216",
"0.5340868",
"0.53357756",
"0.5319597",
"0.52766144",
"0.5271925",
"0.5259718",
"0.5236922",
"0.52361697",
"0.5216407",
"0.5194417",
"0.5152858",
"0.51386267",
"0.51239336",
"0.5107952... | 0.6775266 | 0 |
Configure the double buffer based on size of the widget | def on_configure(self, widget, event, data=None):
print "reconfiguring"
# Destroy previous buffer
if self.double_buffer is not None:
self.double_buffer.finish()
self.double_buffer = None
# Create a new buffer
self.double_buffer = cairo.ImageSurface(cairo.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setBufferSize(self, buffer_size):\n DPxSetDinBuffSize(buffer_size)",
"def _changed_size(self, **kw):\n\t\tself._clear_matrix()\n\t\t\n\t\tself._recalc_adjustments()\n\t\t\n\t\tif self.flags() & gtk.REALIZED:\n\t\t\tif kw.get('resize', True): self.queue_resize()\n\t\t\tif kw.get('draw', True): self.que... | [
"0.610253",
"0.5766414",
"0.5608554",
"0.56082743",
"0.5588019",
"0.55230093",
"0.5471639",
"0.54091835",
"0.5401123",
"0.5401123",
"0.5352664",
"0.53298753",
"0.5326704",
"0.5319585",
"0.53189176",
"0.53112936",
"0.53038687",
"0.5290001",
"0.52694154",
"0.5253243",
"0.524766... | 0.6723716 | 0 |
Shows a category item | def showItem(category_item_id):
return render_template('item.html', item=db.findItem(id=category_item_id)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showCategory(category_id):\n category = session.query(Category).\\\n filter_by(id=category_id).one()\n item = session.query(Item).\\\n filter_by(category_id=category.id)\n return render_template('item.html', category=category, item=item)",
"def showItem(category_id):\n category = se... | [
"0.79654604",
"0.7739004",
"0.7643676",
"0.7522781",
"0.7224209",
"0.702118",
"0.7007901",
"0.69838154",
"0.6969686",
"0.68813515",
"0.67284054",
"0.6714985",
"0.67128104",
"0.6640791",
"0.65600896",
"0.6559297",
"0.65177655",
"0.6493208",
"0.6447697",
"0.6445132",
"0.6391688... | 0.7802788 | 1 |
Allow user to create new catalog item | def newItem():
if request.method == 'POST':
db.createItem(
title=request.form['title'],
description=request.form['description'],
category_id=request.form['category'],
user_id=login_session['user_id'])
flash("New catalog item created!", 'success')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_item(self, user: User, **kwargs) -> None:",
"def addCatalogItem(sport_id):\n\n sport = session.query(Sport).filter_by(id=sport_id).one()\n if request.method == 'POST':\n newCatalogItem = Item(\n name=request.form['itemName'],\n description=request.form['itemDescripti... | [
"0.73387873",
"0.69759136",
"0.69521016",
"0.68233764",
"0.6724789",
"0.66220343",
"0.65843236",
"0.6572441",
"0.6484448",
"0.6453141",
"0.6386233",
"0.6372381",
"0.6363761",
"0.6352616",
"0.6330959",
"0.6315789",
"0.63058573",
"0.6267776",
"0.6242766",
"0.6202442",
"0.618346... | 0.76763475 | 0 |
Allows user to edit an existing category item | def editItem(category_item_id):
editedItem = db.findItem(id=category_item_id)
if editedItem.user_id != login_session['user_id']:
return not_authorized()
if request.method == 'POST':
db.updateItem(editedItem, request.form)
return redirect(url_for('showCatalog'))
return render_temp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def editItem(category_id, item_id):\n editedItem = session.query(Item).filter_by(id=item_id).one()\n category = session.query(Category).filter_by(id=category_id).one()\n\n if editedItem.user_id != login_session['user_id']:\n flash(\"You are authorised to edit items created by you!\")\n ... | [
"0.79928815",
"0.7969549",
"0.79305446",
"0.76757014",
"0.7604712",
"0.7579564",
"0.7493831",
"0.74769086",
"0.74194235",
"0.7385975",
"0.7354665",
"0.73481214",
"0.7337863",
"0.7281295",
"0.7241027",
"0.723668",
"0.71674097",
"0.7164873",
"0.7072671",
"0.70634896",
"0.700564... | 0.82450867 | 0 |
Allows user to delete an existing category item | def deleteItem(category_item_id):
itemToDelete = db.findItem(id=category_item_id)
if itemToDelete.user_id != login_session['user_id']:
return not_authorized()
if request.method == 'POST':
db.deleteItem(itemToDelete)
flash('%s Successfully Deleted' % itemToDelete.title, 'success')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def category_delete(request):\n if request.POST:\n cat = get_object_or_404(Category, pk=request.POST.get('id'))\n cat.delete()\n return HttpResponse(status=200)",
"def deleteCategory():\n deletecategory = deleteCategoryForm()\n # Look for CSRF token in form, verify POST method, and vali... | [
"0.8067774",
"0.8005237",
"0.7868571",
"0.78579575",
"0.7821217",
"0.77969927",
"0.7698097",
"0.7654832",
"0.7649916",
"0.76128393",
"0.75621045",
"0.7551869",
"0.74583393",
"0.74365985",
"0.73939204",
"0.73760337",
"0.734237",
"0.726488",
"0.7225764",
"0.72094333",
"0.717729... | 0.80150735 | 1 |
Returns JSON of all items in catalog | def showItemsJSON():
items = db.getAllItems()
return jsonify(CategoryItems=[i.serialize for i in items]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def catalog_json():\n all_categories = (session.query(Categories).all())\n all_items = (session.query(Items).all())\n return jsonify(categories=([all_categories.serialize\n for all_categories in all_categories]),\n items=([all_items.serialize\n ... | [
"0.853434",
"0.83946824",
"0.7997253",
"0.7965265",
"0.7584442",
"0.7521632",
"0.71851015",
"0.7113346",
"0.7080814",
"0.70294416",
"0.70173",
"0.6980845",
"0.6839632",
"0.68100387",
"0.6775649",
"0.67730457",
"0.6750319",
"0.67496765",
"0.66796345",
"0.6647565",
"0.66201764"... | 0.7908903 | 4 |
Checks if a string is palindromic. | def ispalindrome(string):
if isinstance(string, (str, int, float)):
string = str(string).replace(" ", "").lower()
if len(string) in [0,1]:
return True
half_index = len(string) // 2
first = string[:half_index]
second = string[-half_index:]
if first == secon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def string_palidrome(word):\n if word == string_reverse(word):\n return True\n else:\n return False",
"def is_palindrome(string):\n return",
"def isPalindrome(s):\r\n return isPal(toChars(s))",
"def is_palindromic(n: int) -> bool:\n str_n = str(n)\n if str_n == str_n[::-1]:\n ... | [
"0.8234154",
"0.8193637",
"0.8175128",
"0.8128422",
"0.8093423",
"0.805103",
"0.8046132",
"0.801999",
"0.8012599",
"0.8002301",
"0.79903495",
"0.79647315",
"0.78919333",
"0.7880501",
"0.7864277",
"0.7843781",
"0.78298485",
"0.78054845",
"0.77765304",
"0.7763191",
"0.7761727",... | 0.7539143 | 33 |
Functie om huizen die nog over zijn, efficient aan een batterij te koppelen | def fit_house_in_diamond(houses_copy, batteries):
# Output huis die overgebleven is
output_missing_house = houses_copy[0].get_output()
# Sorteer batterijen resterend capaciteit hoog > laag, en selecteer meest_resterende batterij
batteries.sort(key=lambda battery: battery.get_remaining(), reverse=True)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mezclar_bolsa(self):",
"def apply(self):",
"def podziel(self):\n def fraktal(dlugosc, alpha, poziom):\n \"\"\"Metoda wyznaczajaca fraktal.\n\n Metoda ta przyjmuje dlugosc, kat oraz poziom drzewa.\n Na bazie podanych parametrow wylicza fraktal z podanych w zadaniu wzo... | [
"0.6327021",
"0.6093654",
"0.6040308",
"0.58797973",
"0.58797973",
"0.57834095",
"0.5528101",
"0.54579514",
"0.5450377",
"0.5450377",
"0.5450377",
"0.5450377",
"0.5450377",
"0.5419264",
"0.5408628",
"0.5397332",
"0.5381069",
"0.53769577",
"0.534439",
"0.528647",
"0.527526",
... | 0.0 | -1 |
Compute average return and of steps. | def compute_avg_return_and_steps(environment, policy, num_episodes=10):
total_return = 0.0
total_steps = 0.0
for _ in range(num_episodes):
time_step = environment.reset()
episode_return = 0.0
episode_steps = 0.0
while not time_step.is_last():
action_step = polic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_mean(self, sums, step):\n\n return sums/step",
"def calculate(self):\n avg = self.sum / self.n if self.n != 0 else 0\n self.running_avg.append(avg)\n return avg",
"def average(self):\n return (self.current + self.last) / 2.0",
"def average(self, start, end):\n ... | [
"0.7158892",
"0.6989263",
"0.6973302",
"0.68902016",
"0.67515194",
"0.6697132",
"0.652611",
"0.6519316",
"0.64798063",
"0.6475223",
"0.64444023",
"0.6367762",
"0.630979",
"0.6308836",
"0.62865496",
"0.62865496",
"0.62865496",
"0.62493414",
"0.61997265",
"0.61639595",
"0.61119... | 0.75718766 | 0 |
Collect game episode trajectories. | def collect_episode(environment, policy, num_episodes, replay_buffer_observer):
initial_time_step = environment.reset()
driver = py_driver.PyDriver(
environment,
py_tf_eager_policy.PyTFEagerPolicy(policy, use_tf_function=True),
[replay_buffer_observer],
max_episodes=num_episodes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, episodes: Union[List[\"_Episode\"], \"_Episode\"]):\n if isinstance(episodes, _Episode):\n episodes = [episodes]\n\n for eps in episodes:\n # Make sure we don't change what's coming in from the user.\n # TODO (sven): It'd probably be better to make sure ... | [
"0.6414621",
"0.63026017",
"0.6240498",
"0.6224731",
"0.6224731",
"0.6215807",
"0.6149335",
"0.6149335",
"0.6086121",
"0.6048319",
"0.6045558",
"0.6028511",
"0.6001478",
"0.5987351",
"0.59605205",
"0.59348625",
"0.58955103",
"0.5888853",
"0.5848818",
"0.5830826",
"0.5825047",... | 0.616832 | 6 |
Train and convert the model using TF Agents. | def train_agent(iterations, modeldir, logdir, policydir):
# TODO: add code to instantiate the training and evaluation environments
# TODO: add code to create a reinforcement learning agent that is going to be trained
tf_agent.initialize()
eval_policy = tf_agent.policy
collect_policy = tf_agent... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trainModel( self, featureTrain, classTrain):",
"def run(self) -> None:\n self.model = self.trainer.train_model(self.model, self.data)",
"def training(self) -> None:\n self.compile_model()\n self.train_epoch()\n self.agent.save()",
"def train(self):\n self.emission_model... | [
"0.6938712",
"0.6882058",
"0.6713514",
"0.6688264",
"0.666646",
"0.6585662",
"0.6549936",
"0.6544408",
"0.65219134",
"0.6470889",
"0.6462349",
"0.64333606",
"0.643169",
"0.63435173",
"0.63322496",
"0.63154864",
"0.6292728",
"0.62925255",
"0.62748116",
"0.62622416",
"0.6249937... | 0.6190756 | 32 |
Return the camera's mac address as the serial number. | def serial_number(self) -> str:
return self.mac_address | {
"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 mac(self) -> str:\n return self.camera_info[\"wifi_mac\"]",
"def mac_address(self) -> str:\n return self._device.mac",
"def serial(self) -> str:\n return self.ca... | [
"0.74284977",
"0.7396035",
"0.7244921",
"0.7241079",
"0.7186397",
"0.71549183",
"0.6929182",
"0.6929182",
"0.68750423",
"0.686168",
"0.6835941",
"0.6835715",
"0.68190706",
"0.67833877",
"0.6717112",
"0.6596283",
"0.65792704",
"0.6549326",
"0.6522258",
"0.6508936",
"0.6494126"... | 0.77441496 | 0 |
Return the camera's software version. | def software_version(self) -> str:
return self.data.get(Attribute.SOFTWARE_VERSION) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def software_version(self) -> str:\n return self.camera_info[\"main_sw_version\"]",
"def hardware_version(self) -> str:\n return self.camera_info[\"main_hw_version\"]",
"def get_version(self):\r\n return self._arm.get_version()",
"def firmware_version(self):\n return self._get_system_... | [
"0.89519215",
"0.83684665",
"0.74867046",
"0.73334736",
"0.72057974",
"0.71801555",
"0.7148547",
"0.71403116",
"0.71381164",
"0.7101077",
"0.7082621",
"0.7062264",
"0.6997098",
"0.69791687",
"0.69379365",
"0.69282806",
"0.69030863",
"0.6860852",
"0.6859731",
"0.68596333",
"0.... | 0.7609568 | 2 |
Return True if capture clip on motion is active. | def capture_clip_on_motion(self) -> bool:
return self.data[Attribute.CAPTURE_CLIP_ON_MOTION] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def capture_is_active(self):\n return self.um in self._streams",
"def can_activate(self):\n if self.video_library.get_number_of_video_clips() == 0:\n return False\n else:\n return True",
"def motion_detection_enabled(self):\n return self._motion_status",
"def... | [
"0.6876677",
"0.6634053",
"0.63762534",
"0.6186591",
"0.60965234",
"0.605035",
"0.6013605",
"0.6006316",
"0.5958077",
"0.59114885",
"0.5910525",
"0.5908825",
"0.5908825",
"0.58919317",
"0.58919317",
"0.5860505",
"0.5826048",
"0.5814718",
"0.5800764",
"0.5795898",
"0.5795898",... | 0.8491094 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.