{outf}\",\n 'shape conversion': f\"{inputs[0].shape} -> {outputs[0].shape}\",\n 'hazard': \"Slice layer is converting operand data type.\",\n 'mitigation': mitigation,\n 'help': \"Conversions between float32 and float16 are a red \"\n \"flag, as are conversions between float32/16 <=> INT8.\"\n })\n\n df = pd.DataFrame.from_dict(report, orient='index')\n return df","def compute(cls, observation, prediction, distances):\n\n errors = collections.OrderedDict()\n\n for i in range (0, len(distances)):\n if 'mean_AP1_amp_strong_propagating_at_'+str(distances[i])+'um' in observation.keys() or 'mean_AP1_amp_weak_propagating_at_'+str(distances[i])+'um' in observation.keys():\n p_value = prediction['model_AP1_amp_at_'+str(distances[i])+'um']['mean']\n o_mean = observation['mean_AP1_amp_strong_propagating_at_'+str(distances[i])+'um']\n o_std = observation['std_AP1_amp_strong_propagating_at_'+str(distances[i])+'um']\n\n try:\n error = abs(p_value - o_mean)/o_std\n error = assert_dimensionless(error)\n except (TypeError,AssertionError) as e:\n error = e\n errors['AP1_amp_strong_propagating_at_'+str(distances[i])] = error\n\n\n o_mean = observation['mean_AP1_amp_weak_propagating_at_'+str(distances[i])+'um']\n o_std = observation['std_AP1_amp_weak_propagating_at_'+str(distances[i])+'um']\n\n try:\n error = abs(p_value - o_mean)/o_std\n error = assert_dimensionless(error)\n except (TypeError,AssertionError) as e:\n error = e\n errors['AP1_amp_weak_propagating_at_'+str(distances[i])] = error\n\n else:\n p_value = prediction['model_AP1_amp_at_'+str(distances[i])+'um']['mean']\n o_mean = observation['mean_AP1_amp_at_'+str(distances[i])+'um']\n o_std = observation['std_AP1_amp_at_'+str(distances[i])+'um']\n\n try:\n error = abs(p_value - o_mean)/o_std\n error = assert_dimensionless(error)\n except (TypeError,AssertionError) as e:\n error = e\n errors['AP1_amp_at_'+str(distances[i])] = error\n\n for i in range (0, len(distances)): # to keep better order: first all AP1, then all APlast\n p_value_l = prediction['model_APlast_amp_at_'+str(distances[i])+'um']['mean']\n o_mean_l = observation['mean_APlast_amp_at_'+str(distances[i])+'um']\n o_std_l = observation['std_APlast_amp_at_'+str(distances[i])+'um']\n\n try:\n error_l = abs(p_value_l - o_mean_l)/o_std_l\n error_l = assert_dimensionless(error_l)\n except (TypeError,AssertionError) as e:\n error_l = e\n errors['APlast_amp_at_'+str(distances[i])] = error_l\n\n score_sum_strong_propagating = 0.0\n score_sum_weak_propagating = 0.0\n\n for key, value in errors.iteritems():\n if 'strong' not in key:\n score_sum_weak_propagating += value\n for key, value in errors.iteritems():\n if 'weak' not in key:\n score_sum_strong_propagating += value\n return [score_sum_strong_propagating, score_sum_weak_propagating], errors","def _get_diff2_data(request, ps_left_id, ps_right_id, patch_id, context,\n column_width, patch_filename=None):\n ps_left = models.PatchSet.get_by_id(int(ps_left_id), parent=request.issue.key)\n if ps_left is None:\n return HttpTextResponse(\n 'No patch set exists with that id (%s)' % ps_left_id, status=404)\n ps_left.issue_key = request.issue.key\n ps_right = models.PatchSet.get_by_id(\n int(ps_right_id), parent=request.issue.key)\n if ps_right is None:\n return HttpTextResponse(\n 'No patch set exists with that id (%s)' % ps_right_id, status=404)\n ps_right.issue_key = request.issue.key\n if patch_id is not None:\n patch_right = models.Patch.get_by_id(int(patch_id), parent=ps_right.key)\n else:\n patch_right = None\n if patch_right is not None:\n patch_right.patchset_key = ps_right.key\n if patch_filename is None:\n patch_filename = patch_right.filename\n # Now find the corresponding patch in ps_left\n patch_left = models.Patch.query(\n models.Patch.patchset_key == ps_left.key,\n models.Patch.filename == patch_filename).get()\n\n if patch_left:\n try:\n new_content_left = patch_left.get_patched_content()\n except FetchError as err:\n return HttpTextResponse(str(err), status=404)\n lines_left = new_content_left.lines\n elif patch_right:\n lines_left = patch_right.get_content().lines\n else:\n lines_left = []\n\n if patch_right:\n try:\n new_content_right = patch_right.get_patched_content()\n except FetchError as err:\n return HttpTextResponse(str(err), status=404)\n lines_right = new_content_right.lines\n elif patch_left:\n lines_right = patch_left.get_content().lines\n else:\n lines_right = []\n\n rows = engine.RenderDiff2TableRows(request,\n lines_left, patch_left,\n lines_right, patch_right,\n context=context,\n colwidth=column_width)\n rows = list(rows)\n if rows and rows[-1] is None:\n del rows[-1]\n\n return dict(patch_left=patch_left, patch_right=patch_right,\n ps_left=ps_left, ps_right=ps_right, rows=rows)","def analyze_prior_results(self, analysis_source):\n #TODO: move to iota_run.py\n\n from iota.components.iota_analysis import Analyzer\n from libtbx import easy_pickle as ep\n\n if os.path.isdir(analysis_source):\n int_folder = os.path.abspath(analysis_source)\n else:\n try:\n int_folder = os.path.abspath(os.path.join(os.curdir,\n 'integration/{}/image_objects'.format(analysis_source)))\n except ValueError:\n int_folder = None\n print ('Run #{} not found'.format(analysis_source))\n\n if os.path.isdir(int_folder):\n with prog_message('Analyzing Results'):\n int_list = [os.path.join(int_folder, i) for i in os.listdir(int_folder)]\n img_objects = [ep.load(i) for i in int_list if i.endswith('.int')]\n\n self.logfile = os.path.abspath(os.path.join(int_folder, 'iota.log'))\n self.viz_base = os.path.join('/'.join(int_folder.split('/')),\n 'vizualization')\n\n self.params.analysis.cluster_write_files=False\n\n analysis = Analyzer(self, img_objects, self.iver)\n analysis.print_results()\n analysis.unit_cell_analysis()\n analysis.print_summary(write_files=False)\n else:\n print ('No results found in {}'.format(int_folder))","def _restore_sampler_from_reporter(self, reporter):\n # Read the last iteration reported to ensure we don't include junk\n # data written just before a crash.\n logger.debug(\"Reading storage file {}...\".format(reporter.filepath))\n metadata = reporter.read_dict('metadata')\n thermodynamic_states, unsampled_states = reporter.read_thermodynamic_states()\n\n def _read_options(check_iteration):\n internal_sampler_states = reporter.read_sampler_states(iteration=check_iteration)\n internal_state_indices = reporter.read_replica_thermodynamic_states(iteration=check_iteration)\n internal_energy_thermodynamic_states, internal_neighborhoods, internal_energy_unsampled_states = \\\n reporter.read_energies(iteration=check_iteration)\n internal_n_accepted_matrix, internal_n_proposed_matrix = \\\n reporter.read_mixing_statistics(iteration=check_iteration)\n\n # Search for last cached free energies only if online analysis is activated.\n internal_last_mbar_f_k, internal_last_err_free_energy = None, None\n if self.online_analysis_interval is not None:\n online_analysis_info = self._read_last_free_energy(reporter, check_iteration)\n try:\n internal_last_mbar_f_k, (_, internal_last_err_free_energy) = online_analysis_info\n except TypeError:\n # Trap case where online analysis is set but not run yet and (_, ...) = None is not iterable\n pass\n return (internal_sampler_states, internal_state_indices, internal_energy_thermodynamic_states,\n internal_neighborhoods, internal_energy_unsampled_states, internal_n_accepted_matrix,\n internal_n_proposed_matrix, internal_last_mbar_f_k, internal_last_err_free_energy)\n\n # Keep trying to resume further and further back from the most recent checkpoint back\n checkpoints = reporter.read_checkpoint_iterations()\n checkpoint_reverse_iter = iter(checkpoints[::-1])\n while True:\n try:\n checkpoint = next(checkpoint_reverse_iter)\n output_data = _read_options(checkpoint)\n # Found data, can escape loop\n break\n except StopIteration:\n raise self._throw_restoration_error(\"Attempting to restore from any checkpoint failed. \"\n \"Either your data is fully corrupted or something has gone very \"\n \"wrong to see this message. \"\n \"Please open an issue on the GitHub issue tracker if you see this!\")\n except Exception as err:\n raise err\n # Trap all other errors caught by the load process\n continue\n\n if checkpoint < checkpoints[-1]:\n logger.warning(\"Could not use most recent checkpoint at {}, instead pulled from {}\".format(checkpoints[-1],\n checkpoint))\n (sampler_states, state_indices, energy_thermodynamic_states, neighborhoods, energy_unsampled_states,\n n_accepted_matrix, n_proposed_matrix, last_mbar_f_k, last_err_free_energy) = output_data\n # Assign attributes.\n self._iteration = int(checkpoint) # The int() can probably be removed when pinned to NetCDF4 >=1.4.0\n self._thermodynamic_states = thermodynamic_states\n self._unsampled_states = unsampled_states\n self._sampler_states = sampler_states\n self._replica_thermodynamic_states = np.array(state_indices)\n self._energy_thermodynamic_states = energy_thermodynamic_states\n self._neighborhoods = neighborhoods\n self._energy_unsampled_states = energy_unsampled_states\n self._n_accepted_matrix = np.array(n_accepted_matrix)\n self._n_proposed_matrix = np.array(n_proposed_matrix)\n self._metadata = metadata\n\n self._last_mbar_f_k = last_mbar_f_k\n self._last_err_free_energy = last_err_free_energy\n\n # initialize timing dictionary\n self._timing_data = dict()\n\n # Initialize context caches\n self._initialize_context_caches()","def check_file_locations(store: dict[str, Any]) -> ValidationStepResult:\n success: bool = True\n filtered_files: dict[PullRequestFileType, list[File]] = (\n store[\"filtered_files\"]\n )\n all_labels: dict[str, Label] = store[\"possible_labels\"]\n labels: set[Label] = set()\n comments: list[str] = []\n errors: dict[os.PathLike, list[str]] = {}\n\n forecast_folder_name = store[\"FORECAST_FOLDER_NAME\"]\n logger.info(\n f\"Checking if the PR is updating outside the {forecast_folder_name}/ folder...\"\n )\n if (\n PullRequestFileType.OTHER_NONFS in filtered_files or\n PullRequestFileType.OTHER_FS in filtered_files\n ):\n logger.info((\n \"⚠️ PR contains file changes that are not part of a valid \"\n \"forecast submission (misnamed/misplaced forecast CSV, \"\n \"non CSV files, etc.)\"\n ))\n comments.append(\n \"⚠️ PR contains file changes that are not part of a valid \"\n \"forecast submission (misnamed/misplaced forecast CSV, \"\n \"non CSV files, etc.)\"\n )\n labels.add(all_labels[\"other-files-updated\"])\n\n if (\n PullRequestFileType.MODEL_OTHER_FS in filtered_files \n ):\n success = False\n logger.info((\n \"❌ PR contains files submitted in the model folder that are not part of a valid \"\n \"forecast submission\"\n ))\n comments.append(\n \"❌ PR contains files submitted in the model folder that are not part of a valid \"\n \"forecast submission\"\n )\n \n else:\n logger.info((\n \"✔️ PR does not contain file changes that are not part of a \"\n \"valid forecast submission (misnamed/misplaced forecast CSV, \"\n \"non CSV files, etc.)\"\n ))\n\n logger.info(\"Checking if the PR contains misplaced CSVs...\")\n submission_formatting_instruction = store[\"SUBMISSION_FORMATTING_INSTRUCTION\"]\n\n if (PullRequestFileType.FORECAST not in filtered_files and\n PullRequestFileType.OTHER_FS in filtered_files):\n success = False\n logger.info(\"❌ PR contains misplaced CSVs.\")\n for github_file in filtered_files[PullRequestFileType.OTHER_FS]:\n path = pathlib.Path(github_file.filename)\n errors[path] = [(\n \"The forecast CSV or metadata file is located in an \"\n \"incorrect location and/or is misnamed (see \"\n f\"[here]({submission_formatting_instruction})\"\n \" for submission instructions. Please correct the errors \"\n \"accordingly.\\n\"\n \"We will still check any misplaced CSV(s) for \"\n \"you, so that you can be sure that the CSVs are correct, \"\n \"or correct any actual file content validation errors if \"\n \"not.\"\n )]\n else:\n logger.info(\"✔️ PR does not contain misplaced forecasts\")\n\n logger.info(\"Checking if the PR contains metadata updates...\")\n if PullRequestFileType.METADATA in filtered_files:\n logger.info(\"💡 PR contains metadata updates\")\n comments.append(\"💡 PR contains metadata file changes.\")\n labels.add(all_labels[\"metadata-change\"])\n\n return ValidationStepResult(\n success=success,\n labels=labels,\n comments=comments,\n file_errors=errors\n )","def log_diff(template_index, exists_in_source, source_row, exists_in_dest,\n dest_row):\n\n template = nori.core.cfg['templates'][template_index]\n\n if nori.core.cfg['report_order'] == 'template':\n if template_index not in diff_dict:\n diff_dict[template_index] = []\n diff_dict[template_index].append((exists_in_source, source_row,\n exists_in_dest, dest_row, None))\n diff_k = template_index\n diff_i = len(diff_dict[template_index]) - 1\n elif nori.core.cfg['report_order'] == 'keys':\n keys_str = ()\n if source_row is not None:\n num_keys = source_row[0]\n source_data = source_row[1]\n keys_tuple = source_data[0:num_keys]\n elif dest_row is not None:\n num_keys = dest_row[0]\n dest_data = dest_row[1]\n keys_tuple = dest_data[0:num_keys]\n if keys_tuple not in diff_dict:\n diff_dict[keys_tuple] = []\n diff_dict[keys_tuple].append((template_index, exists_in_source,\n source_row, exists_in_dest, dest_row,\n None))\n diff_k = keys_tuple\n diff_i = len(diff_dict[keys_tuple]) - 1\n\n if exists_in_source:\n source_str = nori.pps(source_row[1])\n elif exists_in_source is None:\n source_str = '[no value match in source database]'\n else:\n source_str = '[no key match in source database]'\n if exists_in_dest:\n dest_str = nori.pps(dest_row[1])\n elif exists_in_dest is None:\n dest_str = '[no value match in destination database]'\n else:\n dest_str = '[no key match in destination database]'\n\n nori.core.status_logger.info(\n 'Diff found for template {0} ({1}):\\nS: {2}\\nD: {3}' .\n format(template_index, nori.pps(template[T_NAME_KEY]),\n source_str, dest_str)\n )\n return (diff_k, diff_i)","def analyze_frame(idx,true_frame, pred_frame):\n global total_act\n global total_correct\n global acts \n global k \n global slots\n global wrong_act_wrong_slot\n global right_act_wrong_slot\n global right_act_right_slot\n global wrong_act_right_slot\n # Compare Dialog Actss\n flag = 0 \n true_act = true_frame['act'] if 'act' in true_frame else None\n pred_act = pred_frame['act'] if 'act' in pred_frame else None\n\n true_act_split = true_act.split(\":\")\n true_act_simple = true_act_split[1] \n true_act_detail = ':'.join(true_act_split[2:])\n\n if pred_act is None : \n wrong_act_wrong_slot.add(idx)\n return None \n pred_act_split = pred_act.split(\":\")\n if pred_act != \"ERR:CHITCHAT\" and pred_act != \"ERR:MISSING_CONTEXT\" and len(pred_act_split) < 3 : \n wrong_act_wrong_slot.add(idx)\n return None \n pred_act_simple = pred_act_split[1] \n pred_act_detail = ':'.join(pred_act_split[2:])\n #ipdb.set_trace(context=20) \n if true_act_simple in acts : \n acts[true_act_simple]['total'] = acts[true_act_simple]['total'] + 1\n if true_act_detail in acts[true_act_simple]['detail'] : ## already exists\n acts[true_act_simple]['detail'][true_act_detail]['total'] += 1\n else : \n if not acts[true_act_simple]['detail'].get(true_act_detail) : \n acts[true_act_simple]['detail'][true_act_detail] = {\n 'total' : 1,\n 'correct' : 0,\n 'all-wrong' : {\n\n },\n 'part-wrong' : {\n\n } \n }\n else :\n acts[true_act_simple] = {\n 'total' : 1,\n 'correct' : 0,\n 'detail' : {\n\n }\n }\n acts[true_act_simple]['detail'][true_act_detail] = {\n 'total' : 1,\n 'correct' : 0,\n 'all-wrong' : {\n\n },\n 'part-wrong' : {\n\n } \n }\n \n if true_act == pred_act : ## Act correctly predicted \n flag = 1\n right_act_right_slot.add(idx)\n total_correct = total_correct + 1\n total_act = total_act + 1 \n acts[true_act_simple]['correct'] += 1\n if acts[true_act_simple]['detail'].get(true_act_detail) is None : \n acts[true_act_simple]['detail'][true_act_detail]['correct'] = 1\n else : \n acts[true_act_simple]['detail'][true_act_detail]['correct'] = acts[true_act_simple]['detail'][true_act_detail]['correct'] + 1\n else : \n\n total_act = total_act + 1 \n #ipdb.set_trace(context=20) \n if true_act_simple == pred_act_simple : ## Correct DA but wrong activities\n if not acts[true_act_simple]['detail'].get(true_act_detail)['part-wrong'] : \n acts[true_act_simple]['detail'].get(true_act_detail)['part-wrong'] = { \n pred_act_detail : 1 \n }\n else :\n if pred_act_detail in acts[true_act_simple]['detail'][true_act_detail]['part-wrong'] : \n acts[true_act_simple]['detail'][true_act_detail]['part-wrong'][pred_act_detail] += 1\n else : \n acts[true_act_simple]['detail'][true_act_detail]['part-wrong'][pred_act_detail] = 1\n\n else : ## All wrong \n if not acts[true_act_simple]['detail'].get(true_act_detail)['all-wrong'] : \n acts[true_act_simple]['detail'].get(true_act_detail)['all-wrong'] = {\n pred_act : 1 \n }\n else :\n if pred_act in acts[true_act_simple]['detail'][true_act_detail]['all-wrong'] : \n acts[true_act_simple]['detail'][true_act_detail]['all-wrong'][pred_act] += 1\n else :\n acts[true_act_simple]['detail'][true_act_detail]['all-wrong'][pred_act] = 1\n \n\n\n # Compare Slots\n true_frame_slot_values = {f'{k}={v}' for k, v in true_frame.get('slots', [])}\n pred_frame_slot_values = {f'{k}={v}' for k, v in pred_frame.get('slots', [])}\n \n if flag == 1 : ## if right DA, check slots \n if true_frame_slot_values == pred_frame_slot_values : ## perfect prediction made \n right_act_right_slot.add(idx)\n else : \n right_act_wrong_slot.add(idx)\n else :\n if true_frame_slot_values == pred_frame_slot_values : \n wrong_act_right_slot.add(idx)\n else :\n wrong_act_wrong_slot.add(idx)","def test_unchanged_status_text(self):\n scale = \"count\"\n metric1 = dict(type=\"metric_type\",\n name=\"Metric\",\n unit=\"units\",\n scale=scale,\n recent_measurements=[dict(count=dict(value=0,\n status=\"near_target_met\")),\n dict(count=dict(value=42,\n status=\"near_target_met\"))])\n metric2 = dict(type=\"metric_type\",\n name=\"Metric\",\n unit=\"units\",\n scale=scale,\n recent_measurements=[dict(count=dict(value=5,\n status=\"target_met\")),\n dict(count=dict(value=10,\n status=\"target_not_met\"))])\n metric_notification_data1 = MetricNotificationData(metric1, self.data_model, \"status_long_unchanged\")\n metric_notification_data2 = MetricNotificationData(metric2, self.data_model, \"status_long_unchanged\")\n notification = Notification(self.report, [metric_notification_data1,\n metric_notification_data2], \"destination_uuid\", {})\n text = build_notification_text(notification)\n self.assertEqual(\n \"[Report 1](https://report1) has 2 metrics that are notable:\\n\\n\"\n \"* Metric has been yellow (near target met) for three weeks. Value: 42 units.\\n\"\n \"* Metric has been red (target not met) for three weeks. Value: 10 units.\\n\",\n text)","def preprocess_one(workcalc):\n \n workcalc_name = workcalc.get_attrs()['_process_label']\n version_preproc_dict = workchain_preproc_and_viewer_info[workcalc_name]\n \n prefix = None\n reason = None\n \n for prefix_version in version_preproc_dict:\n n_calls = version_preproc_dict[prefix_version]['n_calls']\n retr_list_per_step = version_preproc_dict[prefix_version]['retrieved_files']\n \n # ---\n # check if number of calls matches\n if len(workcalc.get_outputs()) < n_calls:\n if reason is None:\n reason = \"Not all calculations started.\"\n continue\n \n # ---\n # check if all specified files are retrieved\n success = True\n for rlps in retr_list_per_step:\n calc_step, retr_list = rlps\n calc = workcalc.get_outputs()[calc_step]\n retrieved_files = calc.out.retrieved.get_folder_list()\n if not all(f in retrieved_files for f in retr_list):\n if reason is None:\n reason = \"Not all files were retrieved.\"\n success = False\n break\n if not success:\n continue\n \n # ---\n # check if the required parameter is there\n if 'req_param' in version_preproc_dict[prefix_version]:\n req_param, req_key = version_preproc_dict[prefix_version]['req_param']\n inp_dict = workcalc.get_inputs_dict()\n if not (req_param in inp_dict and req_key in inp_dict[req_param].dict):\n if reason is None:\n reason = \"Required parameter not existing.\"\n continue\n \n # ---\n # found match! \n prefix = prefix_version\n break\n \n if prefix is None:\n raise(Exception(reason))\n \n structure = workcalc.get_inputs_dict()[version_preproc_dict[prefix]['struct_label']]\n pk_numbers = [e for e in structure.get_extras() if e.startswith(prefix[:-1])]\n pk_numbers = [int(e.split('_')[1]) for e in pk_numbers if e.split('_')[1].isdigit()]\n pks = [e[1] for e in structure.get_extras().items() if e[0].startswith(prefix[:-1])]\n if workcalc.pk in pks:\n return\n nr = 1\n if len(pk_numbers) != 0:\n for nr in range(1, 100):\n if nr in pk_numbers:\n continue\n break\n structure.set_extra('%s_%d_pk'% (prefix, nr), workcalc.pk)","def lf_abnormal_interp_with_spikes(report):\n if 'interpretation' in report.sections.keys():\n interpretation = report.sections['interpretation']\n interp_text = interpretation['text']\n return abnormal_interp_with_spikes(interp_text)\n elif 'summary' in report.sections:\n return abnormal_interp_with_spikes(report.sections['summary']['text'])\n elif 'findings' in report.sections: # fall back to look in the findings \n if 'summary' in report.sections['findings']: # fall back to look for a summary instead\n return abnormal_interp_with_spikes(report.sections['findings']['summary'])\n if 'impression' in report.sections['findings']:\n return abnormal_interp_with_spikes(report.sections['findings']['impression'])\n return ABSTAIN_VAL\n elif 'narrative' in report.sections: # fall back to look in the findings \n ky = 'narrative'\n if 'summary' in report.sections[ky]: # fall back to look for a summary instead\n return abnormal_interp_with_spikes(report.sections[ky]['summary'])\n if 'impression' in report.sections[ky]:\n return abnormal_interp_with_spikes(report.sections[ky]['impression'])\n # could try running on all of findings but would really need to check then\n \n return ABSTAIN_VAL \n else:\n return ABSTAIN_VAL","def rel_errors(self):\n ped_entries = {m[\"patient\"]: m for m in self.pedigree}\n result = {}\n import_job = ImportVariantsBgJob.objects.filter(case_name=self.name).order_by(\n \"-date_created\"\n )\n if import_job and not import_job[0].bg_job.status == \"done\":\n return result\n\n try:\n variant_set = self.latest_variant_set\n if variant_set:\n for rel_stats in variant_set.variant_stats.relatedness.all():\n relationship = \"other\"\n if (\n ped_entries[rel_stats.sample1][\"father\"]\n == ped_entries[rel_stats.sample2][\"father\"]\n and ped_entries[rel_stats.sample1][\"mother\"]\n == ped_entries[rel_stats.sample2][\"mother\"]\n and ped_entries[rel_stats.sample1][\"father\"] != \"0\"\n and ped_entries[rel_stats.sample1][\"mother\"] != \"0\"\n ):\n relationship = \"sibling-sibling\"\n elif (\n ped_entries[rel_stats.sample1][\"father\"] == rel_stats.sample2\n or ped_entries[rel_stats.sample1][\"mother\"] == rel_stats.sample2\n or ped_entries[rel_stats.sample2][\"father\"] == rel_stats.sample1\n or ped_entries[rel_stats.sample2][\"mother\"] == rel_stats.sample1\n ):\n relationship = \"parent-child\"\n if (\n relationship == \"sibling-sibling\"\n and rel_stats.relatedness() < THRESH_SIBLING\n ) or (\n relationship == \"parent-child\" and rel_stats.relatedness() < THRESH_PARENT\n ):\n for sample in (rel_stats.sample1, rel_stats.sample2):\n result.setdefault(sample, []).append(\n (\n \"pedigree shows {} relation for {} and {} but variants show low degree \"\n \"of relatedness\"\n ).format(\n relationship,\n only_source_name(rel_stats.sample1),\n only_source_name(rel_stats.sample2),\n )\n )\n return result\n except SmallVariantSet.variant_stats.RelatedObjectDoesNotExist:\n return {}","def diff_it(self):\n data = {}\n differ = difflib.Differ()\n first = self.first.data.keys()\n first.sort()\n second = self.second.data.keys()\n second.sort()\n # Save data differently if file was measured only in first, only\n # in second or in both reports\n for item in differ.compare(first, second):\n fil = item[2:]\n mode = item[:1]\n if mode == ' ':\n data[fil] = [self.first.data[fil], self.second.data[fil]]\n elif mode == '+':\n data[fil] = [None, self.second.data[fil]]\n elif mode == '-':\n data[fil] = [self.first.data[fil], None]\n return collections.OrderedDict(sorted(data.items()))","def _consist_numeric(col, _df1, _df2, _key1, _key2, img_dir, date_flag=False):\n\n df1, df2 = _df1.copy(), _df2.copy()\n df = pd.merge(df1, df2, left_on=_key1, right_on=_key2, how=\"inner\")\n\n if (df['%s_x' %(col)].dropna().shape[0] == 0) or (df['%s_y' %(col)].dropna().shape[0] == 0):\n if (df['%s_x' %(col)].dropna().shape[0] == 0) and (df['%s_y' %(col)].dropna().shape[0] == 0):\n error_msg = 'all nan in both table'\n elif df['%s_x' %(col)].dropna().shape[0] == 0:\n error_msg = 'all nan in table1'\n else:\n error_msg = 'all nan in table2'\n return {'column': col, 'error_msg': error_msg}\n\n df = df.dropna(how='any', subset=['%s_x' % (col), '%s_y' % (col)]).reset_index(drop=True)\n df['diff_temp'] = df['%s_y' %(col)] - df['%s_x' %(col)]\n corr = round(spearmanr(df['%s_x' %(col)].values, df['%s_y' %(col)].values)[0], 3)\n\n output = [\n {'feature': 'column', 'value': col, 'graph': 'consistency check'},\n {'feature': 'corr', 'value': corr},\n {'feature': 'min diff', 'value': round(df['diff_temp'].min(), 3)},\n {'feature': 'mean diff', 'value': round(df['diff_temp'].mean(), 3)},\n {'feature': 'median diff', 'value': round(df['diff_temp'].median(), 3)},\n {'feature': 'max diff', 'value': round(df['diff_temp'].max(), 3)},\n ]\n\n draw_values = df['diff_temp'].dropna().values\n origin_value_4 = [np.min(draw_values), np.mean(draw_values), np.median(draw_values), np.max(draw_values)]\n\n # get distribution\n scale_flg = 0\n draw_value_4 = origin_value_4\n if np.max([abs(origin_value_4[0]), abs(origin_value_4[3])]) >= pow(10, 6):\n scale_flg = 1\n draw_values, draw_value_4 = _get_scale_draw_values(draw_values, draw_value_4)\n\n # draw the scatter plot\n both_min = np.min([df['%s_x' %(col)].min(), df['%s_y' %(col)].min()])\n both_max = np.max([df['%s_x' %(col)].max(), df['%s_y' %(col)].max()])\n\n dpi = 72\n plt.figure(figsize=(635. / dpi, 635. / (9. / 4.) / dpi), dpi=dpi)\n plt.subplot(121)\n plt.title('Scatter plot for values')\n plt.scatter(df['%s_x' %(col)].values, df['%s_y' %(col)].values, c=TABLE1_DARK, s=5)\n plt.plot([both_min, both_max], [both_min, both_max], '--', c='#bbbbbb')\n\n plt.xlim(both_min, both_max)\n plt.ylim(both_min, both_max)\n\n ax2 = plt.subplot(122)\n if len(np.unique(draw_values)) <= 10:\n sns.countplot(draw_values, palette=sns.color_palette([TABLE2_DARK]))\n if len(np.unique(draw_values)) > 5:\n plt.xticks(rotation=90)\n else:\n sns.distplot(draw_values, color=TABLE2_DARK)\n y_low, y_up = ax2.get_ylim()\n _draw_texts(text_values=origin_value_4, draw_value_4=draw_value_4, mark=1, y_low=y_low, y_up=y_up)\n\n if date_flag:\n plt.title('Distribution of differences (in months)')\n elif scale_flg:\n plt.title('Distribution of differences (log10 scale)')\n else:\n plt.title('Distribution of differences')\n\n # save the graphs\n # adjust graph name\n graph_name = col\n if '/' in graph_name:\n graph_name = graph_name.replace('/', '')\n plt.savefig(os.path.join(img_dir, graph_name + '.png'), transparent=True, dpi=dpi)\n return {'column': col, 'result_df': pd.DataFrame(output), 'corr': {'column': col, 'corr': corr}}","def compute_advice(self):\n for advice in self:\n old_lines = self.env['hr.payroll.advice.line'].search([('advice_id', '=', advice.id)])\n if old_lines:\n old_lines.unlink()\n payslips = self.env['hr.payslip'].search([('date_from', '<=', advice.date), ('date_to', '>=', advice.date), ('state', '=', 'done')])\n for slip in payslips:\n if not slip.sudo().employee_id.bank_account_id and not slip.sudo().employee_id.bank_account_id.acc_number:\n raise UserError(_('Please define bank account for the %s employee') % (slip.employee_id.name,))\n payslip_line = self.env['hr.payslip.line'].search([('slip_id', '=', slip.id), ('code', '=', 'NET')], limit=1)\n if payslip_line:\n self.env['hr.payroll.advice.line'].create({\n 'advice_id': advice.id,\n 'name': slip.sudo().employee_id.bank_account_id.acc_number,\n 'ifsc_code': slip.sudo().employee_id.bank_account_id.bank_bic or '',\n 'employee_id': slip.employee_id.id,\n 'bysal': payslip_line.total\n })\n slip.advice_id = advice.id"],"string":"[\n \"def get_diffs(history):\\n\\n # First get all possible representations\\n mgr = plugins_get_mgr() \\n keys = mgr.search('representation')['representation']\\n representations = [mgr.get_by_key('representation', k) for k in keys]\\n\\n for i in range(len(history)):\\n if i+1 > len(history) - 1:\\n continue\\n\\n prev = history[i]\\n curr = history[i+1]\\n\\n #print(prev['subject'], \\\"==>\\\", curr['subject'])\\n #print(curr['changes'])\\n for c in curr['changes']:\\n \\n path = c['path']\\n\\n # Skip the metadata file\\n if c['path'].endswith('datapackage.json'): \\n continue \\n\\n # Find a handler for this kind of file...\\n handler = None \\n for r in representations: \\n if r.can_process(path): \\n handler = r \\n break \\n \\n if handler is None: \\n continue \\n\\n # print(path, \\\"being handled by\\\", handler)\\n\\n v1_hex = prev['commit']\\n v2_hex = curr['commit']\\n\\n temp1 = tempfile.mkdtemp(prefix=\\\"dgit-diff-\\\") \\n \\n try: \\n for h in [v1_hex, v2_hex]: \\n filename = '{}/{}/checkout.tar'.format(temp1, h)\\n try:\\n os.makedirs(os.path.dirname(filename))\\n except:\\n pass \\n extractcmd = ['git', 'archive', '-o', filename, h, path]\\n output = run(extractcmd)\\n if 'fatal' in output: \\n raise Exception(\\\"File not present in commit\\\") \\n with cd(os.path.dirname(filename)): \\n cmd = ['tar', 'xvf', 'checkout.tar']\\n output = run(cmd) \\n if 'fatal' in output: \\n print(\\\"Cleaning up - fatal 1\\\", temp1)\\n shutil.rmtree(temp1)\\n continue \\n\\n # Check to make sure that \\n path1 = os.path.join(temp1, v1_hex, path) \\n path2 = os.path.join(temp1, v2_hex, path) \\n if not os.path.exists(path1) or not os.path.exists(path2): \\n # print(\\\"One of the two output files is missing\\\") \\n shutil.rmtree(temp1)\\n continue \\n\\n #print(path1, path2) \\n\\n # Now call the handler\\n diff = handler.get_diff(path1, path2)\\n\\n # print(\\\"Inserting diff\\\", diff)\\n c['diff'] = diff\\n\\n except Exception as e: \\n #traceback.print_exc() \\n #print(\\\"Cleaning up - Exception \\\", temp1)\\n shutil.rmtree(temp1)\",\n \"def apply_decisions(base, decisions):\\n\\n merged = copy.deepcopy(base)\\n prev_path = None\\n parent = None\\n last_key = None\\n resolved = None\\n diffs = None\\n # clear_parent actions should override other decisions on same obj, so\\n # we need to track it\\n clear_parent_flag = False\\n for md in decisions:\\n path, line = split_string_path(merged, md.common_path)\\n # We patch all decisions with the same path in one op\\n if path == prev_path:\\n # Same path as previous, collect entry\\n if clear_parent_flag:\\n # Another entry will clear the parent, all other decisions\\n # should be dropped\\n pass\\n else:\\n if md.action == \\\"clear_parent\\\":\\n clear_parent_flag = True\\n # Clear any exisiting decsions!\\n diffs = []\\n ad = resolve_action(resolved, md)\\n if line:\\n ad = push_path(line, ad)\\n diffs.extend(ad)\\n\\n else:\\n # Different path, start a new collection\\n if prev_path is not None:\\n # First, apply previous diffs\\n if parent is None:\\n # Operations on root create new merged object\\n merged = patch(resolved, diffs)\\n else:\\n # If not, overwrite entry in parent (which is an entry in\\n # merged). This is ok, as no paths should point to\\n # subobjects of the patched object\\n parent[last_key] = patch(resolved, diffs)\\n\\n prev_path = path\\n # Resolve path in base and output\\n resolved = merged\\n parent = None\\n last_key = None\\n for key in path:\\n parent = resolved\\n resolved = resolved[key] # Should raise if key missing\\n last_key = key\\n diffs = resolve_action(resolved, md)\\n if line:\\n diffs = push_path(line, diffs)\\n clear_parent_flag = md.action == \\\"clear_parent\\\"\\n # Apply the last collection of diffs, if present (same as above)\\n if prev_path is not None:\\n if parent is None:\\n merged = patch(resolved, diffs)\\n else:\\n parent[last_key] = patch(resolved, diffs)\\n\\n merged = nbformat.from_dict(merged)\\n return merged\",\n \"def compute_audit(self):\\r\\n \\r\\n time = datetime.now()\\r\\n H0_dist = []\\r\\n Ha_dist = []\\r\\n\\r\\n for i in range(0, self.m):\\r\\n #print(\\\"CURRENT H0 dist: \\\", H0_dist)\\r\\n #try:\\r\\n H0_dist = self.next_round_dist(True, H0_dist, i)\\r\\n Ha_dist = self.next_round_dist(False, Ha_dist, i)\\r\\n '''\\r\\n except Exception as e:\\r\\n \\r\\n print(e)\\r\\n self.bad = H0_dist\\r\\n self.bad2 = Ha_dist\\r\\n return\\r\\n '''\\r\\n self.decide_k_min(H0_dist, Ha_dist, i)\\r\\n #print('ROUND INDEX: ',i,'kminschedl: ',self.k_min_sched[i])\\r\\n\\r\\n #self.truncate_dist(H0_dist, i)\\r\\n H0_dist = H0_dist[:self.k_min_sched[i]]\\r\\n #self.truncate_dist(Ha_dist, i)\\r\\n Ha_dist = Ha_dist[:self.k_min_sched[i]]\\r\\n \\r\\n #print(\\\"The outputs: k_mins, LR denominator, LR numerator, 1 / LR (or alpha').\\\")\\r\\n #print(self.k_min_sched, '\\\\n', self.pr_H0_sched, '\\\\n', self.pr_Ha_sched, '\\\\n', \\r\\n #self.risk_sched)\\r\\n #print(\\\"Output suppressed. Use instance variables k_min_sched, pr_H0_sched, pr_Ha_sched, risk_sched\\\")\\r\\n\\r\\n #print(\\\"Time elapsed:\\\", datetime.now() - time)\\r\",\n \"def diff_report(self) -> str:\\n graph_a = self.graph_a\\n graph_b = self.graph_b\\n\\n graph_a_str = str(graph_a)\\n graph_b_str = str(graph_b)\\n\\n if graph_a_str == graph_b_str:\\n return \\\"\\\"\\n\\n graph_diff = difflib.ndiff(\\n graph_a_str.splitlines(True), graph_b_str.splitlines(True)\\n )\\n graph_diff_report = [\\\"Graph diff:\\\", self._indent(\\\"\\\".join(graph_diff))]\\n\\n for node_a, node_b in itertools.zip_longest(graph_a.nodes(), graph_b.nodes()):\\n if str(node_a) != str(node_b):\\n graph_diff_report.append(\\\"First diverging operator:\\\")\\n node_diff = difflib.ndiff(\\n str(node_a).splitlines(True), str(node_b).splitlines(True)\\n )\\n source_printout = [\\\"node diff:\\\", self._indent(\\\"\\\".join(node_diff))]\\n\\n stack_a = node_a.sourceRange() if node_a else None\\n if stack_a:\\n source_printout.extend(\\n [\\\"Former source location:\\\", self._indent(str(stack_a))]\\n )\\n stack_b = node_b.sourceRange() if node_b else None\\n if stack_b:\\n source_printout.extend(\\n [\\\"Latter source location:\\\", self._indent(str(stack_b))]\\n )\\n\\n graph_diff_report.extend(source_printout)\\n\\n break\\n\\n return \\\"\\\\n\\\".join(graph_diff_report)\",\n \"def compare_readbacks(golden_path,\\n readback_path):\\n\\n errors_cram = 0\\n seu_01 = 0\\n seu_10 = 0\\n mbu_pos = 0\\n mbu_neg = 0\\n mbu_delta = []\\n\\n golden = open(golden_path, \\\"rb\\\")\\n readback = open(readback_path, \\\"rb\\\")\\n\\n golden_array = golden.read()\\n readback_array = readback.read()\\n print(len(golden_array))\\n print(len(readback_array))\\n\\n for i in range(0, len(golden_array)):\\n if golden_array[i] != readback_array[i]:\\n gold_byte, = struct.unpack(\\\"B\\\", golden_array[i])\\n gold_byte_ones = bin(gold_byte).count(\\\"1\\\")\\n readback_byte, = struct.unpack(\\\"B\\\", readback_array[i])\\n readback_byte_ones = bin(readback_byte).count(\\\"1\\\")\\n\\n delta = gold_byte_ones - readback_byte_ones\\n\\n if delta == -1:\\n seu_01 += 1\\n elif delta == 1:\\n seu_10 += 1\\n elif delta > 1:\\n mbu_pos += 1\\n mbu_delta.append(delta)\\n print(\\\"\\\\n\\\\n\\\\n\\\\n\\\\n DUPA \\\\n\\\\n\\\\n\\\\n\\\\n\\\")\\n elif delta < -1:\\n mbu_neg += 1\\n mbu_delta.append(delta)\\n print(\\\"\\\\n\\\\n\\\\n\\\\n\\\\n DUPA \\\\n\\\\n\\\\n\\\\n\\\\n\\\")\\n\\n print(gold_byte,\\n readback_byte,\\n delta)\\n\\n errors_cram += 1\\n\\n print(\\\"\\\\n\\\\nseu_01: {0}\\\\nseu_10: {1}\\\\nmbu_01: {2}\\\\nmbu_10: {3}\\\".format(seu_01, seu_10, mbu_neg, mbu_pos))\\n print(mbu_delta)\\n golden.close()\\n readback.close()\\n\\n return errors_cram\",\n \"def PostProcessDiff(self, diff):\\r\\n return diff\",\n \"def analyze_data():\\n attack_free_1 = load_messages(\\\"data/csv/Attack_free_dataset.csv\\\", verbose=True)\\n\\n impersonation_1 = load_messages(\\\"data/csv/170907_impersonation.csv\\\", verbose=True)\\n impersonation_2 = load_messages(\\\"data/csv/170907_impersonation_2.csv\\\", verbose=True)\\n impersonation_3 = load_messages(\\\"data/csv/Impersonation_attack_dataset.csv\\\", verbose=True)\\n\\n information = {\\n \\\"Mean time between normal messages\\\":\\n get_mean_time_between_normal_messages(attack_free_1),\\n \\\"Mean time between split messages\\\":\\n get_mean_time_between_split_messages(attack_free_1),\\n \\\"Sum of removed intervals in '170907_impersonation.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_1, 250),\\n \\\"Sum of removed intervals in '170907_impersonation_2.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_2, 250),\\n \\\"Sum of removed intervals in 'Impersonation_attack_dataset.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_3, 250),\\n \\\"Index of split in '170907_impersonation.csv'\\\":\\n get_index_before_time(impersonation_1, 250 - 23.434627056121826),\\n \\\"Index of split in '170907_impersonation_2.csv'\\\":\\n get_index_before_time(impersonation_2, 250 - 20.980855226516724),\\n \\\"Index of split in 'Impersonation_attack_dataset.csv'\\\":\\n get_index_before_time(impersonation_3, 250 - 2.1056361198425293)\\n }\\n\\n return information\",\n \"def compare_old_and_new_status_files():\\n rdict=dict()\\n mastcontrol=dirutil.get_mast_control_path()\\n mastscratch=dirutil.get_mast_scratch_path()\\n recipedirs=dirutil.immediate_subdirs(os.path.join(mastcontrol,\\\"statusfiles\\\"))\\n for recipedir in recipedirs:\\n mystatus=\\\"unknown\\\"\\n rdict[recipedir]=dict()\\n changelist=list()\\n if not os.path.exists(os.path.join(mastscratch,recipedir)):\\n mystatus=\\\"archived\\\"\\n else:\\n scratchstatusfile = MASTFile(os.path.join(mastscratch,recipedir,\\\"status.txt\\\"))\\n controlstatusfile = MASTFile(os.path.join(mastcontrol,\\\"statusfiles\\\",recipedir,\\\"status.txt\\\"))\\n if scratchstatusfile.data == controlstatusfile.data:\\n mystatus=\\\"unchanged\\\"\\n else:\\n mystatus=\\\"changed\\\"\\n myidx=0\\n while myidx < len(scratchstatusfile.data):\\n oldline = controlstatusfile.data[myidx]\\n newline = scratchstatusfile.data[myidx]\\n if \\\"#\\\" in oldline:\\n pass\\n else:\\n ingred = oldline.split(\\\":\\\")[0].strip()\\n oldstatus = oldline.split(\\\":\\\")[1].strip()\\n newstatus = newline.split(\\\":\\\")[1].strip()\\n if (oldstatus == \\\"P\\\") and (newstatus == \\\"P\\\"):\\n rdict[recipedir][ingred]=\\\"AVOID\\\"\\n elif (oldstatus == \\\"C\\\") and (newstatus == \\\"C\\\"):\\n rdict[recipedir][ingred]=\\\"AVOID\\\"\\n else:\\n rdict[recipedir][ingred]=\\\"send\\\"\\n myidx = myidx + 1\\n rdict[recipedir][\\\"MAIN\\\"]=mystatus\\n return rdict\",\n \"def _get_diff_data(views_index, src_data, ea_index, ddi_data):\\n\\n def _add_and_del():\\n \\\"\\\"\\\"Handles the add's and del import's.\\\"\\\"\\\"\\n for add_or_del_row in src_data:\\n # Add Check.\\n if 'add' in add_or_del_row[0]:\\n if add_or_del_row[1] in \\\\\\n ddi_data[views_index[add_or_del_row[15]]]:\\n errored_list.append(add_or_del_row)\\n continue\\n else:\\n import_add.append(add_or_del_row)\\n continue\\n\\n # delete check\\n if 'del' in add_or_del_row[0] and add_or_del_row[1] in \\\\\\n ddi_data[views_index[add_or_del_row[15]]][\\n add_or_del_row[1]]:\\n import_delete.append([add_or_del_row[15],\\n add_or_del_row[1],\\n add_or_del_row[14]])\\n continue\\n unused_list.append(add_or_del_row)\\n\\n def _ea_in_disposition_col0_and_empty_ipr_d_col():\\n \\\"\\\"\\\"Disposition col0 check and an empty ipr disposition column.\\\"\\\"\\\"\\n for disposition_row in unused_list:\\n # Check disposition\\n ddi_index = views_index[disposition_row[15]]\\n # Checks disposition column value and checks for IPR D value.\\n # If no IPR D in extattrs dict stores the src data for updates.\\n if disposition_row[0] in ea_ipr_d_values and 'IPR Designation' not\\\\\\n in ddi_data[ddi_index][disposition_row[1]]['extattrs']:\\n import_merge_disposition.append(\\n [disposition_row[15],\\n disposition_row[1],\\n disposition_row[14],\\n disposition_row[0]])\\n\\n def _comment_check():\\n \\\"\\\"\\\"Function for checking ipam comment attribute.\\\"\\\"\\\"\\n for comment_row in unused_list:\\n ddi_index = views_index[comment_row[15]]\\n # Checks for empty src value and empty ddi data value.\\n # Continues if True.\\n if 'comment' not in ddi_data[ddi_index][comment_row[1]]\\\\\\n and comment_row[12] == '':\\n continue\\n # Checks a non-empty src value and updates if an\\n # empty ddi data value.\\n if 'comment' not in ddi_data[ddi_index][comment_row[1]] and \\\\\\n comment_row[12] != '':\\n import_merge.append([comment_row[15],\\n comment_row[1],\\n comment_row[14],\\n {'comment': comment_row[12]}])\\n continue\\n # Checks diff against src value and a populated value in the\\n # ddi data and replaces with src value.\\n if comment_row[12] != \\\\\\n ddi_data[ddi_index][comment_row[1]]['comment']:\\n import_override.append([comment_row[15],\\n comment_row[1],\\n comment_row[14],\\n {'comment': comment_row[12]}])\\n continue\\n\\n def _non_listed_ea_columns_check():\\n \\\"\\\"\\\"Checks non-listable ea columns.\\\"\\\"\\\"\\n for ea_row in unused_list:\\n # dup Check in disposition\\n ddi_index = views_index[ea_row[15]]\\n for key, value in ea_index.items():\\n # ea attributes that could be listed.\\n if key == 'Datacenter' or key == 'IPR Designation':\\n continue\\n # Checks for empty src value and empty ddi data value.\\n # Continues if True.\\n if key not in ddi_data[ddi_index][ea_row[1]]['extattrs'] and \\\\\\n ea_row[value] in ['', 'DDI']:\\n continue\\n # Checks a non-empty src value and updates if an\\n # empty ddi data value.\\n if key not in ddi_data[ddi_index][ea_row[1]]['extattrs'] \\\\\\n and ea_row[value] not in ['', 'DDI']:\\n import_merge.append([ea_row[15],\\n ea_row[1],\\n ea_row[14],\\n {key: ea_row[value]}])\\n continue\\n # Checks diff against src value and a populated value in the\\n # ddi data and replaces with src value.\\n if ea_row[value] != \\\\\\n ddi_data[ddi_index][\\n ea_row[1]]['extattrs'][key]['value']:\\n import_override.append([ea_row[15],\\n ea_row[1],\\n ea_row[14],\\n {key: ea_row[value]}])\\n continue\\n\\n def _listed_ea_column_check():\\n \\\"\\\"\\\"Checks non-listable ea columns.\\\"\\\"\\\"\\n for ea_row in unused_list:\\n ddi_index = views_index[ea_row[15]]\\n # This check is performed in\\n # _ea_in_disposition_col0_and_empty_ipr_d_col\\n if ea_row[0] in ea_ipr_d_values and \\\\\\n 'IPR Designation' not in \\\\\\n ddi_data[ddi_index][ea_row[1]]['extattrs']:\\n continue\\n # Update IPR D src column with ea_row[0] for processing.\\n # WORK IN PROGRESS\\n elif ea_row[0] in ea_ipr_d_values and 'IPR Designation' \\\\\\n in ddi_data[ddi_index][ea_row[1]]['extattrs']:\\n pass\\n # Processing listable columns.\\n for key, value in ea_index.items():\\n # Skip's unused keys.\\n if key not in ['Datacenter', 'IPR Designation']:\\n continue\\n # Check for blank column and blank source column.\\n if key not in ddi_data[ddi_index][ea_row[1]]['extattrs'] and \\\\\\n ea_row[value] in ['', 'DDI']:\\n continue\\n # Check for Disposition col, check for comma not in IPR D col\\n # value, check value in IPR D col to ea ipr d attribute list,\\n # check IPR D col value eq ddi value.\\n # On not listed IPR D values.\\n if key == 'IPR Designation':\\n if ea_row[0] in ea_ipr_d_values \\\\\\n and ',' not in ea_row[16] \\\\\\n and ea_row[16] in ea_ipr_d_values:\\n ea_row[16] = ea_row[16] + ',' + ea_row[0]\\n import_override.append([ea_row[15].strip(),\\n ea_row[1].strip(),\\n ea_row[14].strip(),\\n {key: ea_row[16]}])\\n continue\\n # Check for Disposition col, check for comma not in IPR D col\\n # value, check value in IPR D col to ea ipr d attribute list,\\n # check IPR D col value eq ddi value.\\n # On not listed IPR D values.\\n elif ea_row[0] in ea_ipr_d_values \\\\\\n and ',' not in ea_row[16] \\\\\\n and ea_row[16] not in ea_ipr_d_values:\\n import_override.append([ea_row[15].strip(),\\n ea_row[1].strip(),\\n ea_row[14].strip(),\\n {key: ea_row[0]}])\\n continue\\n# # Check Disposition col. and if IPR D listed value needs\\n# # updating. On listed IPR D values.\\n# if ea_row[0].lower().strip() in ea_ipr_d_values \\\\\\n# and ',' in ea_row[16]:\\n# temp_list = ea_row[16].split(',')\\n# temp_list = [x.strip() for x in temp_list]\\n# if ea_row[0].lower().strip() in temp_list:\\n# continue\\n# else:\\n# temp_list.append(ea_row[0].lower().strip())\\n# temp_dict_override.update({key: temp_list})\\n# import_override.append([ea_row[15].strip(),\\n# ea_row[1].strip(),\\n# ea_row[14].strip(),\\n# temp_dict_override])\\n# continue\\n\\n # Builds dataset for non-listed values. Final Step.\\n # If key not in ddi data and src value is not none.\\n # Assign to merge.\\n if key not in ddi_data[ddi_index][ea_row[1]]['extattrs'] \\\\\\n and ea_row[value] not in ['', 'DDI']:\\n import_merge.append([ea_row[15].strip(),\\n ea_row[1].strip(),\\n ea_row[14].strip(),\\n {key: ea_row[value]}])\\n continue\\n # Checks diff against src value and a populated value in the\\n # ddi data and replaces with src value.\\n if ea_row[value] != \\\\\\n ddi_data[ddi_index][\\n ea_row[1]]['extattrs'][key]['value']:\\n import_override.append([ea_row[15],\\n ea_row[1],\\n ea_row[14],\\n {key: ea_row[value]}])\\n continue\\n\\n # Local scope variables.\\n import_add = []\\n import_delete = []\\n import_merge = []\\n import_override = []\\n import_merge_disposition = []\\n unused_list = []\\n errored_list = []\\n # Check for extensible attribute in Disposition column[0].\\n # If found and IPR D column is empty append for writing.\\n ea_ipr_d_values = ['leaf', 'dup', 'followup', 'decom', 'adv', 'divest',\\n 'ignore', 're-ip', 'parent', 'drop reserve']\\n _add_and_del()\\n _ea_in_disposition_col0_and_empty_ipr_d_col()\\n _comment_check()\\n _non_listed_ea_columns_check()\\n _listed_ea_column_check()\\n return import_add, \\\\\\n import_delete, \\\\\\n import_merge_disposition, \\\\\\n import_merge, \\\\\\n import_override\",\n \"def analyze_state_changes(self):\\n graph = self._graph\\n lost_chunks = set(self._lost_chunks)\\n op_states = self._op_states\\n\\n # mark lost virtual nodes as lost when some preds are lost\\n for n in graph:\\n if not isinstance(n.op, VirtualOperand) \\\\\\n or op_states.get(n.op.key) == OperandState.UNSCHEDULED:\\n continue\\n if any(pred.key in lost_chunks for pred in graph.iter_predecessors(n)):\\n lost_chunks.add(n.key)\\n\\n # collect operands with lost data\\n op_key_to_chunks = defaultdict(list)\\n lost_ops = set()\\n for n in graph:\\n op_key_to_chunks[n.op.key].append(n)\\n if n.key in lost_chunks:\\n lost_ops.add(n.op.key)\\n\\n # check data on finished operands. when data lost, mark the operand\\n # and its successors as affected.\\n affected_op_keys = set()\\n for op_key in lost_ops:\\n affected_op_keys.add(op_key)\\n for n in op_key_to_chunks[op_key]:\\n affected_op_keys.update(succ.op.key for succ in graph.iter_successors(n))\\n\\n # scan the graph from bottom and reassign new states\\n new_states = dict()\\n for chunk in graph.topological_iter(reverse=True):\\n op_key = chunk.op.key\\n if chunk.op.key not in affected_op_keys:\\n continue\\n\\n can_be_ready = True\\n stop_spread_states = (OperandState.RUNNING, OperandState.FINISHED)\\n for pred in graph.iter_predecessors(chunk):\\n pred_op_key = pred.op.key\\n # mark affected, if\\n # 1. data of the operand is lost\\n # 2. state does not hold data, or data is lost,\\n # for instance, operand is freed.\\n if pred.key in lost_chunks or op_states.get(pred_op_key) not in stop_spread_states:\\n affected_op_keys.add(pred_op_key)\\n can_be_ready = False\\n\\n # update state given data preservation of prior nodes\\n chunk_op_state = op_states.get(op_key)\\n if can_be_ready and chunk_op_state != OperandState.READY:\\n new_states[op_key] = OperandState.READY\\n elif not can_be_ready and chunk_op_state != OperandState.UNSCHEDULED:\\n new_states[op_key] = OperandState.UNSCHEDULED\\n\\n op_states.update(new_states)\\n return new_states\",\n \"def __diff_internal(self):\\n assert self.p > 0, \\\"order of Bspline must be > 0\\\" # we already handle the other case in diff()\\n\\n # https://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/B-spline/bspline-derv.html\\n #\\n t = self.knot_vector\\n p = self.p\\n bi = BsplineBasis(t[:-1], p - 1)\\n bip1 = BsplineBasis(t[1:], p - 1)\\n\\n numer1 = +p\\n numer2 = -p\\n denom1 = t[p:-1] - t[:-(p + 1)]\\n denom2 = t[(p + 1):] - t[1:-p]\\n\\n with np.errstate(divide='ignore', invalid='ignore'):\\n ci = np.where(denom1 != 0., (numer1 / denom1), 0.)\\n cip1 = np.where(denom2 != 0., (numer2 / denom2), 0.)\\n\\n return (ci, bi), (cip1, bip1)\",\n \"def comparison():\\n path = \\\"Data/data_fronts/\\\"\\n path1 = \\\"Results/labelled_images1010/fronts/\\\"\\n\\n #computes the areas for the first frame in order to normalize the other areas\\n pol0 = pd.DataFrame(pd.read_csv(path1 + \\\"fronts_labelled.m.0.png.txt\\\",sep =' '))\\n #makes an object polygon in order to compute the area\\n pol0 = np.array(pol0)\\n pol0 = Polygon(pol0)\\n\\n polsx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_1_sx.txt\\\",sep ='\\\\t'))\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n poldx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_1_dx.txt\\\",sep ='\\\\t'))\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n #makes an object polygon in order to compute the area\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n pol1 = Polygon(polsx)\\n\\n\\n areas = []\\n areas_hand = []\\n #computes the areas for all the frames\\n for i in range(42):\\n pol = pd.DataFrame(pd.read_csv(path1 + \\\"fronts_labelled.m.\\\"+str(i)+\\\".png.txt\\\",sep =' '))\\n pol = np.array(pol)\\n pol = Polygon(pol)\\n #normalize the areas with respect to the area of the first frame\\n areas.append(pol.area/pol0.area)\\n\\n polsx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_\\\"+str(i+1)+\\\"_sx.txt\\\",sep ='\\\\t'))\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n poldx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_\\\"+str(i+1)+\\\"_dx.txt\\\",sep ='\\\\t'))\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n if poldx[\\\"x\\\"][0]>100:\\n poldx = poldx.reindex(index=poldx.index[::-1])\\n if polsx[\\\"x\\\"][0]<100:\\n polsx = polsx.reindex(index=polsx.index[::-1])\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n\\n pol2 = Polygon(polsx)\\n #normalize the areas with respect to the area of the first frame\\n areas_hand.append(pol2.area/pol1.area)\\n #returns the two arrays with the normalized areas\\n return np.array(areas) , np.array(areas_hand)\",\n \"def fast_comparison(path = \\\"Data/data_fronts/\\\",path1 = \\\"Results/modified_images/fronts/\\\"):\\n #computes the areas for the first frame in order to normalize the other areas\\n pol0dx = grid(path1+\\\"m_0.png_dx.txt\\\")\\n pol0dx.columns = [\\\"y\\\",\\\"x\\\"]\\n pol0sx = grid(path1+\\\"m_0.png_sx.txt\\\")\\n pol0sx.columns = [\\\"y\\\",\\\"x\\\"]\\n if pol0dx[\\\"x\\\"][0]>100:\\n pol0dx = pol0dx.reindex(index=pol0dx.index[::-1])\\n if pol0sx[\\\"x\\\"][0]<100:\\n pol0sx = pol0sx.reindex(index=pol0sx.index[::-1])\\n pol0sx = pol0sx.append(pol0dx)\\n pol0sx = np.array(pol0sx)\\n pol0 = Polygon(pol0sx)\\n\\n polsx = grid(path + \\\"Sham_8-2-18_Field 5_1_sx.txt\\\",l = 633,delimiter ='\\\\t')\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n polsx[\\\"y\\\"] =polsx[\\\"y\\\"]/844*1600\\n polsx[\\\"x\\\"] =polsx[\\\"x\\\"]/633*1200\\n poldx = grid(path + \\\"Sham_8-2-18_Field 5_1_dx.txt\\\",l = 633,delimiter ='\\\\t')\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n poldx[\\\"y\\\"] =poldx[\\\"y\\\"]/844*1600\\n poldx[\\\"x\\\"] =poldx[\\\"x\\\"]/633*1200\\n if poldx[\\\"x\\\"][0]>100:\\n poldx = poldx.reindex(index=poldx.index[::-1])\\n if polsx[\\\"x\\\"][0]<100:\\n polsx = polsx.reindex(index=polsx.index[::-1])\\n #makes an object polygon in order to compute the area\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n pol1 = Polygon(polsx)\\n\\n\\n areas = []\\n areas_hand = []\\n #computes the areas for all the frames\\n for i in range(42):\\n poldx = grid(path1+\\\"m_\\\"+str(i)+\\\".png_dx.txt\\\")\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n polsx = grid(path1+\\\"m_\\\"+str(i)+\\\".png_sx.txt\\\")\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n if poldx[\\\"x\\\"][0]>100:\\n poldx = poldx.reindex(index=poldx.index[::-1])\\n if polsx[\\\"x\\\"][0]<100:\\n polsx = polsx.reindex(index=polsx.index[::-1])\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n\\n #makes an object polygon in order to compute the area\\n\\n pol = Polygon(polsx)\\n\\n #normalize the areas with respect to the area of the first frame\\n areas.append(pol.area/pol0.area)\\n\\n polsx = grid(path + \\\"Sham_8-2-18_Field 5_\\\"+str(i+1)+\\\"_sx.txt\\\",l = 633,delimiter ='\\\\t')\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n polsx[\\\"y\\\"] =polsx[\\\"y\\\"]/844*1600\\n polsx[\\\"x\\\"] =polsx[\\\"x\\\"]/633*1200\\n poldx = grid(path + \\\"Sham_8-2-18_Field 5_\\\"+str(i+1)+\\\"_dx.txt\\\",l = 633,delimiter='\\\\t')\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n poldx[\\\"y\\\"] =poldx[\\\"y\\\"]/844*1600\\n poldx[\\\"x\\\"] =poldx[\\\"x\\\"]/633*1200\\n if poldx[\\\"x\\\"][0]>100:\\n poldx = poldx.reindex(index=poldx.index[::-1])\\n if polsx[\\\"x\\\"][0]<100:\\n polsx = polsx.reindex(index=polsx.index[::-1])\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n\\n pol2 = Polygon(polsx)\\n #normalize the areas with respect to the area of the first frame\\n areas_hand.append(pol2.area/pol1.area)\\n #returns the two arrays with the normalized areas\\n return np.array(areas) , np.array(areas_hand)\",\n \"def _analyze(self):\\r\\n if self.value is None or self.value == self.previous:\\r\\n pass\\r\\n elif self._operation == \\\"add\\\":\\r\\n self._additions = self.value\\r\\n elif self._operation == \\\"remove\\\":\\r\\n self._removals = self.value\\r\\n elif self.previous is None:\\r\\n self._assignments = self.value\\r\\n else:\\r\\n # partial update time\\r\\n self._additions = (self.value - self.previous) or None\\r\\n self._removals = (self.previous - self.value) or None\\r\\n self._analyzed = True\",\n \"def process_traces(subdirs,dates,load_path):\\n\\n N = 60*60*24*len(dates)*10\\n\\n firing_rates_storage = np.zeros((N))\\n var_storage = np.zeros((N))\\n position_storage = np.zeros((N,2))\\n firing_rates_storage[:] = np.nan\\n var_storage[:] = np.nan\\n timestamps = np.zeros((N))\\n clusters = np.zeros((N))\\n pk_max = 0\\n n=0\\n\\n for subdir,date in zip(subdirs,dates):\\n \\n dpk = pk_max \\n path = load_path+'/%s/'%subdir\\n file = [i for i in os.listdir(path) if '.pkl' in i] \\n \\n if len(file) == 0:\\n continue\\n \\n pd_ob = pkl.load(open(path+file[0],'rb'))\\n \\n positions = pd_ob['positions']\\n sts = pd_ob['sts']\\n isis = pd_ob['isis']\\n fsts = pd_ob['fsts']\\n fisis = pd_ob['fisis']\\n et = pd_ob['et']\\n ep = pd_ob['ep']\\n \\n max_time = 0\\n for k,v in sts.items():\\n max_time = max(max_time,np.max(v))\\n \\n for t in np.arange(0,np.floor(max_time)):\\n\\n for i,pk in enumerate(sts.keys()):\\n if np.count_nonzero((sts[pk]>t) & (sts[pk]<(t+1))) > 1:\\n\\n p = positions[pk][:-1]\\n\\n x = sts[pk]\\n y = isis[pk]\\n fx = fsts[pk]\\n fy = fisis[pk]\\n\\n firing_rates_storage[n] = np.nanmean(y[(x>t) & (x<t+1)])\\n var_storage[n] = np.nanvar(y[(x>t) & (x<t+1)])\\n position_storage[n] = np.nanmean(p[(x>t) & (x<t+1)],axis=0)\\n timestamps[n] = (date + timedelta(0,int(t))).timestamp()\\n clusters[n] = pk + dpk\\n n=n+1\\n pk_max = max(pk_max,pk+dpk)\\n\\n firing_rates_storage = firing_rates_storage[:n]\\n var_storage = var_storage[:n]\\n position_storage = position_storage[:n]\\n timestamps = timestamps[:n]\\n clusters = clusters[:n]\\n\\n np.savez(load_path+'processed_traces.npz',frs=firing_rates_storage,vs=var_storage,pos=position_storage,ts=timestamps,cl=clusters)\\n return 0\",\n \"def test_calculate_indicates_removal_of_unrelated_files(self, m_free):\\n # files are unrelated to backup\\n walk_paths = {'/dst': [('/dst', ['/a'], ['x0.txt']),\\n ('/dst/a', [], ['x1.txt'])]}\\n copied_indexes = []\\n reconciler = keepfilesreconciler.KeepFilesReconciler(self.resolver, self.options)\\n with filesystemhelpers.mock_walk(walk_paths):\\n filepaths = reconciler.calculate(self.copyfiles, copied_indexes)\\n assert filepaths == {'/dst/a/x1.txt', '/dst/x0.txt'}\",\n \"def compare_old_and_new_change_status_files():\\n rdict=dict()\\n mastcontrol=dirutil.get_mast_control_path()\\n mastscratch=dirutil.get_mast_scratch_path()\\n recipedirs=dirutil.immediate_subdirs(os.path.join(mastcontrol,\\\"changestatusfiles\\\"))\\n for recipedir in recipedirs:\\n mystatus=\\\"unknown\\\"\\n rdict[recipedir]=dict()\\n changelist=list()\\n if not os.path.exists(os.path.join(mastscratch,recipedir)):\\n mystatus=\\\"archived\\\"\\n else:\\n ingreddirs = dirutil.immediate_subdirs(os.path.join(mastcontrol,\\\"changestatusfiles\\\",recipedir))\\n for ingreddir in ingreddirs:\\n scratchstatusfile = MASTFile(os.path.join(mastscratch,recipedir,ingreddir,\\\"change_status.txt\\\"))\\n controlstatusfile = MASTFile(os.path.join(mastcontrol,\\\"changestatusfiles\\\",recipedir,ingreddir,\\\"change_status.txt\\\"))\\n if scratchstatusfile.data == controlstatusfile.data:\\n mystatus=\\\"unchanged\\\"\\n else:\\n mystatus=\\\"changed\\\"\\n rdict[recipedir][ingreddir]=\\\"send\\\"\\n rdict[recipedir][\\\"MAIN\\\"]=mystatus\\n return rdict\",\n \"def check_unstaged_changes(self):\\n pass\",\n \"def _average_plan_diffs(self, server_config: dict, cycle):\\n logging.info(\\\"start diffs averaging!\\\")\\n logging.info(\\\"cycle: %s\\\" % str(cycle))\\n logging.info(\\\"fl id: %d\\\" % cycle.fl_process_id)\\n _model = model_manager.get(fl_process_id=cycle.fl_process_id)\\n logging.info(\\\"model: %s\\\" % str(_model))\\n model_id = _model.id\\n logging.info(\\\"model id: %d\\\" % model_id)\\n _checkpoint = model_manager.load(model_id=model_id)\\n logging.info(\\\"current checkpoint: %s\\\" % str(_checkpoint))\\n model_params = model_manager.unserialize_model_params(_checkpoint.values)\\n logging.info(\\\"model params shapes: %s\\\" % str([p.shape for p in model_params]))\\n\\n # Here comes simple hardcoded avg plan\\n # it won't be always possible to retrieve and unserialize all diffs due to memory constrains\\n # needs some kind of iterative or streaming approach,\\n # e.g.\\n # for diff_N in diffs:\\n # avg = avg_plan(avg, N, diff_N)\\n # and the plan is:\\n # avg_next = (avg_current*(N-1) + diff_N) / N\\n reports_to_average = self._worker_cycles.query(\\n cycle_id=cycle.id, is_completed=True\\n )\\n diffs = [\\n model_manager.unserialize_model_params(report.diff)\\n for report in reports_to_average\\n ]\\n\\n # Again, not sure max_workers == number of diffs to avg\\n diffs = random.sample(diffs, server_config.get(\\\"max_workers\\\"))\\n\\n raw_diffs = [\\n [diff[model_param] for diff in diffs]\\n for model_param in range(len(model_params))\\n ]\\n logging.info(\\\"raw diffs lengths: %s\\\" % str([len(row) for row in raw_diffs]))\\n\\n sums = [reduce(th.add, param) for param in raw_diffs]\\n logging.info(\\\"sums shapes: %s\\\" % str([sum.shape for sum in sums]))\\n\\n diff_avg = [th.div(param, len(diffs)) for param in sums]\\n logging.info(\\\"diff_avg shapes: %s\\\" % str([d.shape for d in diff_avg]))\\n\\n # apply avg diff!\\n _updated_model_params = [\\n model_param - diff_param\\n for model_param, diff_param in zip(model_params, diff_avg)\\n ]\\n logging.info(\\n \\\"_updated_model_params shapes: %s\\\"\\n % str([p.shape for p in _updated_model_params])\\n )\\n\\n # make new checkpoint\\n serialized_params = model_manager.serialize_model_params(_updated_model_params)\\n _new_checkpoint = model_manager.save(model_id, serialized_params)\\n logging.info(\\\"new checkpoint: %s\\\" % str(_new_checkpoint))\\n\\n # mark current cycle completed\\n cycle.is_completed = True\\n self._cycles.update()\\n\\n completed_cycles_num = self._cycles.count(\\n fl_process_id=cycle.fl_process_id, is_completed=True\\n )\\n logging.info(\\\"completed_cycles_num: %d\\\" % completed_cycles_num)\\n max_cycles = server_config.get(\\\"num_cycles\\\")\\n if completed_cycles_num < max_cycles:\\n # make new cycle\\n _new_cycle = self.create(cycle.fl_process_id, cycle.version)\\n logging.info(\\\"new cycle: %s\\\" % str(_new_cycle))\\n else:\\n logging.info(\\\"FL is done!\\\")\",\n \"def compute_error_metrics(original, altered, results, converterOpts=None):\\n import math\\n from tempfile import TemporaryDirectory\\n\\n import large_image_source_tiff\\n import numpy as np\\n import packaging\\n import skimage.metrics\\n\\n lastlog = 0\\n with TemporaryDirectory() as tempDir:\\n # TODO: check if the original is geospatial; if so appropriate options\\n tempPath = os.path.join(tempDir, os.path.basename(original) + '.tiff')\\n orig = large_image_converter.convert(original, tempPath, compression='lzw')\\n tsOrig = large_image_source_tiff.open(orig)\\n numFrames = len(tsOrig.getMetadata().get('frames', [0]))\\n tsAlt = large_image_source_tiff.open(altered)\\n mse = 0\\n ssim = 0\\n ssim_count = 0\\n maxval = 0\\n maxdiff = 0\\n sum = 0\\n count = 0\\n tileSize = 2048\\n for frame in range(numFrames):\\n tiAlt = tsAlt.tileIterator(tile_size=dict(width=tileSize), frame=frame)\\n for tileOrig in tsOrig.tileIterator(tile_size=dict(width=tileSize), frame=frame):\\n tileAlt = next(tiAlt)\\n do = tileOrig['tile']\\n da = tileAlt['tile']\\n if do.dtype != da.dtype and da.dtype == np.uint8:\\n da = da.astype(int) * 257\\n do = do.astype(int)\\n da = da.astype(int)\\n maxval = max(maxval, do.max(), da.max())\\n if do.shape[2] > da.shape[2]:\\n do = do[:, :, :da.shape[2]]\\n if da.shape[2] > do.shape[2]:\\n da = da[:, :, :do.shape[2]]\\n diff = np.absolute(do - da)\\n maxdiff = max(maxdiff, diff.max())\\n sum += diff.sum()\\n count += diff.size\\n last_mse = np.mean(diff ** 2)\\n mse += last_mse * diff.size\\n last_ssim = 0\\n try:\\n kwargs = {}\\n if (packaging.version.parse(skimage.__version__) >=\\n packaging.version.parse('0.19')):\\n kwargs['channel_axis'] = 2 if len(do.shape) > 2 else None\\n else:\\n kwargs['multichannel'] = len(do.shape) > 2\\n last_ssim = skimage.metrics.structural_similarity(\\n do.astype(float), da.astype(float),\\n data_range=255 if tileOrig['tile'].dtype == np.uint8 else 65535,\\n gaussian_weights=True, sigma=1.5, use_sample_covariance=False,\\n **kwargs)\\n ssim += last_ssim * diff.size\\n ssim_count += diff.size\\n except ValueError:\\n pass\\n if time.time() - lastlog >= 10 and ssim_count:\\n logger.debug(\\n 'Calculating error (%d/%d): rmse %4.2f ssim %6.4f '\\n 'last rmse %4.2f ssim %6.4f',\\n tileOrig['tile_position']['position'] + 1 +\\n tileOrig['iterator_range']['position'] * frame,\\n tileOrig['iterator_range']['position'] * numFrames,\\n (mse / count) ** 0.5, ssim / ssim_count,\\n last_mse ** 0.5, last_ssim)\\n lastlog = time.time()\\n results['maximum_error'] = maxdiff\\n results['average_error'] = sum / count\\n results['rmse'] = (mse / count) ** 0.5\\n results['psnr'] = 10 * math.log10(\\n maxval ** 2 / (mse / count)) if mse else None\\n if ssim_count:\\n results['ssim'] = ssim / ssim_count\\n logger.debug('Calculated error: rmse %4.2f psnr %3.1f ssim %6.4f',\\n results['rmse'], results['psnr'] or 0, results['ssim'])\",\n \"def get_resulting_diffs():\\n diff_dirpath = application.join_abs_path(\\n EMPTY_TEST_DIR, application.OUTPUT_DIR_NAME)\\n diffleft_filename = application.join_abs_path(\\n diff_dirpath, application.OUTPUT_DIFF_LEFT_FILENAME)\\n diffright_filename = application.join_abs_path(\\n diff_dirpath, application.OUTPUT_DIFF_RIGHT_FILENAME)\\n\\n diff_left = read_gzip_file_lines_into_set(diffleft_filename)\\n diff_right = read_gzip_file_lines_into_set(diffright_filename)\\n\\n return diff_left, diff_right\",\n \"def avg_metric(sharp_path, deblurred_path): # TODO1 do multiprocessing in those methods\\n sum_psnr = 0\\n sum_mse = 0\\n sum_ssim = 0\\n\\n # List all files\\n files_orig = [f for f in listdir(sharp_path) if isfile(join(sharp_path, f))]\\n files_deb = [f for f in listdir(deblurred_path) if isfile(join(deblurred_path, f))]\\n\\n count = 0\\n for orig, deb in zip(files_orig, files_deb):\\n orig_fn = join(sharp_path, orig)\\n deb_fn = join(deblurred_path, deb)\\n # Load images\\n orig_img = cv2.imread(orig_fn)\\n deb_img = cv2.imread(deb_fn)\\n orig_img = np.divide(orig_img, 255)\\n deb_img = np.divide(deb_img, 255)\\n\\n # Compute metrics\\n sum_psnr += peak_signal_noise_ratio(orig_img, deb_img)\\n sum_mse += mean_squared_error(orig_img, deb_img)\\n sum_ssim += structural_similarity(orig_img, deb_img, multichannel=True)\\n\\n count += 1\\n print('Analyzed: {}/{}'.format(count, len(files_orig)))\\n\\n # Average\\n avg_psnr = sum_psnr/len(files_orig)\\n avg_mse = sum_mse/len(files_orig)\\n avg_ssim = sum_ssim/len(files_orig)\\n\\n return avg_mse, avg_psnr, avg_ssim\",\n \"def check_error(self):\\n refine_results = {}\\n for phase_path, phase in self.phases.items():\\n refine_results[phase_path] = {}\\n\\n # Save the original grid to the refine results\\n tx = phase.options['transcription']\\n gd = tx.grid_data\\n num_nodes = gd.subset_num_nodes['all']\\n numseg = gd.num_segments\\n\\n refine_results[phase_path]['num_segments'] = numseg\\n refine_results[phase_path]['order'] = gd.transcription_order\\n refine_results[phase_path]['segment_ends'] = gd.segment_ends\\n refine_results[phase_path]['need_refinement'] = np.zeros(numseg, dtype=bool)\\n refine_results[phase_path]['error'] = np.zeros(numseg, dtype=float)\\n\\n if isinstance(tx, dm.RungeKutta):\\n continue\\n\\n outputs = phase.list_outputs(units=False, out_stream=None)\\n\\n out_values_dict = {k: v['value'] for k, v in outputs}\\n\\n prom_to_abs_map = phase._var_allprocs_prom2abs_list['output']\\n\\n num_scalar_states = 0\\n for state_name, options in phase.state_options.items():\\n shape = options['shape']\\n size = np.prod(shape)\\n num_scalar_states += size\\n\\n x = np.zeros([num_nodes, num_scalar_states])\\n f = np.zeros([num_nodes, num_scalar_states])\\n c = 0\\n\\n # Obtain the solution on the current grid\\n for state_name, options in phase.state_options.items():\\n prom_name = f'timeseries.states:{state_name}'\\n abs_name = prom_to_abs_map[prom_name][0]\\n rate_source_prom_name = f\\\"timeseries.state_rates:{state_name}\\\"\\n rate_abs_name = prom_to_abs_map[rate_source_prom_name][0]\\n x[:, c] = out_values_dict[prom_name].ravel()\\n f[:, c] = out_values_dict[rate_source_prom_name].ravel()\\n c += 1\\n\\n # Obtain the solution on the new grid\\n # interpolate x at t_hat\\n new_order = gd.transcription_order + 1\\n # Gauss-Lobatto does not allow even orders so increase order by 2 instead\\n if gd.transcription == 'gauss-lobatto':\\n new_order += 1\\n new_grid = GridData(numseg, gd.transcription, new_order, gd.segment_ends, gd.compressed)\\n left_end_idxs = new_grid.subset_node_indices['segment_ends'][0::2]\\n left_end_idxs = np.append(left_end_idxs, new_grid.subset_num_nodes['all'] - 1)\\n\\n L = interpolation_lagrange_matrix(gd, new_grid)\\n I = integration_matrix(new_grid)\\n\\n # Call the ODE at all nodes of the new grid\\n x_hat, x_prime = self.eval_ode(phase, new_grid, L, I)\\n E = {}\\n e = {}\\n err_over_states = {}\\n for state_name, options in phase.state_options.items():\\n E[state_name] = np.absolute(x_prime[state_name] - x_hat[state_name])\\n for k in range(0, numseg):\\n e[state_name] = E[state_name]/(1 + np.max(x_hat[state_name][left_end_idxs[k]:left_end_idxs[k + 1]]))\\n err_over_states[state_name] = np.zeros(numseg)\\n\\n for state_name, options in phase.state_options.items():\\n for k in range(0, numseg):\\n err_over_states[state_name][k] = np.max(e[state_name][left_end_idxs[k]:left_end_idxs[k + 1]])\\n\\n self.error[phase_path] = np.zeros(numseg)\\n refine_results[phase_path]['error'] = np.zeros(numseg)\\n refine_results[phase_path]['need_refinement'] = np.zeros(numseg, dtype=bool)\\n\\n # Assess the errors in each state\\n for state_name, options in phase.state_options.items():\\n for k in range(0, numseg):\\n if err_over_states[state_name][k] > self.error[phase_path][k]:\\n self.error[phase_path][k] = err_over_states[state_name][k]\\n refine_results[phase_path]['error'][k] = err_over_states[state_name][k]\\n if self.error[phase_path][k] > phase.refine_options['tolerance']:\\n refine_results[phase_path]['need_refinement'][k] = True\\n\\n return refine_results\",\n \"def errdump_analysis(errdump_df, switchshow_df, switch_params_aggregated_df, \\n portshow_aggregated_df, project_constants_lst):\\n \\n # imported project constants required for module execution\\n project_steps_df, max_title, io_data_names_df, _, report_headers_df, report_columns_usage_sr, *_ = project_constants_lst\\n\\n # data titles obtained after module execution (output data)\\n # data titles which module is dependent on (input data)\\n data_names, analyzed_data_names = dfop.list_from_dataframe(io_data_names_df, 'errorlog_analysis_out', 'errorlog_analysis_in')\\n # module information\\n meop.show_module_info(project_steps_df, data_names)\\n # read data from database if they were saved on previos program execution iteration\\n data_lst = dbop.read_database(project_constants_lst, *data_names)\\n \\n # force run when any output data from data_lst is not found in database or \\n # procedure execution explicitly requested (force_run flag is on) for any output or input data \\n force_run = meop.verify_force_run(data_names, data_lst, project_steps_df, \\n max_title, analyzed_data_names)\\n if force_run:\\n # data imported from init file (regular expression patterns) to extract values from data columns\\n pattern_dct, _ = sfop.regex_pattern_import('raslog_split', max_title)\\n raslog_message_details_df = sfop.dataframe_import('raslog_details', max_title)\\n raslog_message_id_details_df = sfop.dataframe_import('raslog_id_details', max_title, columns=['Message_ID', 'Details', 'Recommended_action'])\\n\\n # current operation information string\\n info = f'Counting RASLog messages'\\n print(info, end =\\\" \\\")\\n\\n # get aggregated DataFrames\\n errdump_aggregated_df = errdump_aggregated(errdump_df, switchshow_df, switch_params_aggregated_df, \\n portshow_aggregated_df, pattern_dct)\\n # count how many times event appears during one month for the last six months \\n raslog_counter_df, raslog_frequent_df = errdump_statistics(errdump_aggregated_df, raslog_message_details_df, raslog_message_id_details_df)\\n # after finish display status\\n meop.status_info('ok', max_title, len(info)) \\n # partition aggregated DataFrame to required tables\\n raslog_report_df = raslog_report(raslog_frequent_df, data_names, report_headers_df, report_columns_usage_sr)\\n\\n # create list with partitioned DataFrames\\n data_lst = [errdump_aggregated_df, raslog_counter_df, raslog_report_df]\\n # writing data to sql\\n dbop.write_database(project_constants_lst, data_names, *data_lst)\\n # verify if loaded data is empty and replace information string with empty DataFrame\\n else:\\n data_lst = dbop.verify_read_data(max_title, data_names, *data_lst)\\n errdump_aggregated_df, raslog_counter_df, *_ = data_lst\\n # save data to service file if it's required\\n for data_name, data_frame in zip(data_names, data_lst):\\n report.dataframe_to_excel(data_frame, data_name, project_constants_lst)\\n return errdump_aggregated_df, raslog_counter_df\",\n \"def __getHoldingsTransferred(self, dirPath=None):\\n trsfD = {}\\n insD = {}\\n dirPath = dirPath if dirPath else self.__sandboxPath\\n\\n try:\\n fp = os.path.join(dirPath, \\\"status\\\", \\\"theoretical_model_obsolete.tsv\\\")\\n lineL = self.__mU.doImport(fp, \\\"list\\\") # pylint: disable=no-member\\n #\\n obsDateD = {}\\n obsIdD = {}\\n for line in lineL:\\n fields = line.split(\\\"\\\\t\\\")\\n if len(fields) < 3:\\n continue\\n entryId = str(fields[0]).strip().upper()\\n obsDateD[entryId] = dateutil.parser.parse(fields[2]) if self.__assignDates else fields[2]\\n if len(fields) > 3 and len(fields[3]) > 3:\\n obsIdD[entryId] = str(fields[3]).strip().upper()\\n logger.debug(\\\"Read %d obsolete insilico id codes\\\", len(obsDateD))\\n # --------- --------- --------- --------- --------- --------- ---------\\n fp = os.path.join(dirPath, \\\"status\\\", \\\"model-archive-PDB-insilico-mapping.list\\\")\\n lineL = self.__mU.doImport(fp, \\\"list\\\")\\n #\\n trD = {}\\n for line in lineL:\\n fields = line.split(\\\":\\\")\\n if len(fields) < 2:\\n continue\\n entryId = str(fields[1]).strip().upper()[:4]\\n maId = str(fields[0]).strip()\\n trD[entryId] = maId\\n logger.debug(\\\"Read %d model archive id codes\\\", len(trD))\\n #\\n # --------- --------- --------- --------- --------- --------- ---------\\n fp = os.path.join(dirPath, \\\"status\\\", \\\"theoretical_model_v2.tsv\\\")\\n lineL = self.__mU.doImport(fp, \\\"list\\\")\\n #\\n logger.debug(\\\"Read %d insilico id codes\\\", len(lineL))\\n for line in lineL:\\n fields = str(line).split(\\\"\\\\t\\\")\\n if len(fields) < 6:\\n continue\\n depDate = dateutil.parser.parse(fields[2]) if self.__assignDates else fields[2]\\n relDate = None\\n if len(fields[3]) >= 10 and not fields[3].startswith(\\\"0000\\\"):\\n relDate = dateutil.parser.parse(fields[3]) if self.__assignDates else fields[3]\\n\\n statusCode = \\\"TRSF\\\" if fields[1] == \\\"REL\\\" else fields[1]\\n\\n entryId = str(fields[0]).upper()\\n title = fields[4]\\n #\\n auditAuthors = [t.strip() for t in fields[5].split(\\\";\\\")]\\n repId = None\\n repName = None\\n if entryId in trD:\\n repName = \\\"Model Archive\\\"\\n repId = trD[entryId]\\n\\n #\\n dD = {\\n \\\"status_code\\\": statusCode,\\n \\\"deposit_date\\\": depDate,\\n \\\"repository_content_types\\\": [\\\"coordinates\\\"],\\n \\\"title\\\": title,\\n \\\"audit_authors\\\": auditAuthors,\\n }\\n #\\n if relDate:\\n dD[\\\"release_date\\\"] = relDate\\n #\\n if repId:\\n dD[\\\"remote_accession_code\\\"] = repId\\n dD[\\\"remote_repository_name\\\"] = repName\\n if statusCode == \\\"TRSF\\\":\\n trsfD[entryId] = dD\\n #\\n #\\n dD = {\\\"status_code\\\": statusCode, \\\"deposit_date\\\": depDate, \\\"title\\\": title, \\\"audit_authors\\\": auditAuthors}\\n #\\n if relDate:\\n dD[\\\"release_date\\\"] = relDate\\n #\\n if entryId in obsDateD:\\n dD[\\\"remove_date\\\"] = relDate\\n #\\n if entryId in obsIdD:\\n dD[\\\"id_codes_replaced_by\\\"] = [obsIdD[entryId]]\\n #\\n insD[entryId] = dD\\n #\\n logger.info(\\\"Transferred entries %d - insilico models %d\\\", len(trsfD), len(insD))\\n #\\n except Exception as e:\\n logger.exception(\\\"Failing with %s\\\", str(e))\\n\\n return trsfD, insD\",\n \"def main_pipeline(self, image):\\n # detection\\n t0 = datetime.now()\\n bbox_list, score_list, label_list = self.det.inference(image)\\n t1 = datetime.now()\\n logging.info('main pipeline (det): {}'.format(get_tdiff(t0, t1)))\\n \\n # estimation\\n t0 = datetime.now()\\n disp = self.est.inference(image)\\n depth_list = self.est.calc_depth(bbox_list)\\n t1 = datetime.now()\\n logging.info('main pipeline (est): {}'.format(get_tdiff(t0, t1)))\\n \\n # tracker predict\\n t0 = datetime.now()\\n for t in self.t_list:\\n t.predict()\\n t1 = datetime.now()\\n logging.info('main pipeline (trk_pred): {}'.format(get_tdiff(t0, t1)))\\n \\n # associate\\n t0 = datetime.now()\\n matched_pair, unmatched_bbox_list, _ = associate(bbox_list, label_list, self.t_list)\\n t1 = datetime.now()\\n logging.info('main pipeline (da_solver): {}'.format(get_tdiff(t0, t1)))\\n \\n t0 = datetime.now()\\n # update trackers for matched_pair\\n for m in matched_pair:\\n t = self.t_list[m[1]]\\n bbox = bbox_list[m[0]]\\n depth = depth_list[m[0]]\\n est_dict = {\\n 'label': label_list[m[0]],\\n 'score': score_list[m[0]]}\\n t.update(self.frame_idx, bbox, depth, est_dict)\\n \\n # update in-track status of all trackers\\n for t in self.t_list:\\n t.update_status(self.frame_idx)\\n \\n # purge out dead trackers\\n self.t_list = [t for t in self.t_list if t.get_status()]\\n\\n # create new trackers for unmatched_bbox_list\\n for b_idx in unmatched_bbox_list:\\n bbox = bbox_list[b_idx]\\n depth = depth_list[b_idx]\\n est_dict = {\\n 'label': label_list[b_idx],\\n 'score': score_list[b_idx]}\\n self.t_list.append(tracker(self.t_cfg, self.tid_new, bbox, depth, est_dict))\\n self.tid_new += 1\\n\\n t1 = datetime.now()\\n logging.info('main pipeline (trk_upd): {}'.format(get_tdiff(t0, t1)))\\n\\n # disparity map for display\\n return disp\",\n \"def read_inversion_info(file_dic):\\n #print_file_test = open('file_test.txt','w')\\n\\n if not ( check_inversion_files(file_dic) ):\\n print 'error(read_inversion_info): problem with lenstool file names'\\n return 0\\n \\n file_generate_arcs = file_dic['file_generate_arcs']\\n info_input_lens = fc.extract_second_identifiers( file_generate_arcs, \\\\\\n 'potential' )\\n#-------------------------------------------------------------------------------\\n\\n file_source = file_dic['file_source']\\n info_src = np.loadtxt(file_source, unpack=False)\\n if len(info_src) == 8 and np.isscalar(info_src[0]):\\n #FIXME - check if the second condition is all we need\\n info_src = [info_src]\\n#-------------------------------------------------------------------------------\\n\\n file_make_inversion = file_dic['file_make_inversion']\\n info_fited_param = fc.extract_second_identifiers( file_make_inversion, \\\\\\n 'limit' )\\n info_forme = fc.extract_parameter(file_make_inversion, 'forme')[0][0]\\n\\n#-------------------------------------------------------------------------------\\n\\n file_best_fit = file_dic['file_best_fit']\\n info_best_fit = fc.extract_second_identifiers( file_best_fit, \\\\\\n 'potentiel' )\\n\\n info_xi2 = fc.extract_parameter(file_best_fit, '#Chi2pos:')\\n\\n#-------------------------------------------------------------------------------\\n file_chires = file_dic['file_chires']\\n\\n info_chires = extract_parameter(file_chires, '0')\\n rmss_mean = [0.0, 0.0]\\n rmsi_mean = [0.0, 0.0]\\n for i in info_chires:\\n if i[0] != 'A':\\n rmss_mean[0] = rmss_mean[0] + float(i[7])\\n rmss_mean[1] = rmss_mean[1] + 1.0\\n \\n rmsi_mean[0] = rmsi_mean[0] + float(i[8])\\n rmsi_mean[1] = rmsi_mean[1] + 1.0\\n\\n rmss_mean = rmss_mean[0]/rmss_mean[1]\\n rmsi_mean = rmsi_mean[0]/rmsi_mean[1]\\n#-------------------------------------------------------------------------------\\n out_dict = { 'xi2' : float(info_xi2[0][0]), \\\\\\n 'best_fit_lens' : info_best_fit, \\\\\\n 'rmsi_mean' : rmsi_mean, \\\\\\n 'rmss_mean' : rmss_mean, \\\\\\n 'fited_parameters' : info_fited_param[0].keys(), \\\\\\n 'input_lens' : info_input_lens[len(info_input_lens) - 1], \\\\\\n 'forme' : info_forme \\\\\\n }\\n #for i in out_dict.keys():\\n # print i, out_dict[i]\\n return out_dict\",\n \"def compute_differences(pts_important, jparams):\\n print(\\\"=== Computing differences ===\\\")\\n start = time.time()\\n print(\\\"start measuring time of compute_differences\\\")\\n input_data = rasterio.open(jparams[\\\"input-file\\\"])\\n out_profile = input_data.profile\\n out_profile['dtype'] = 'float32'\\n raw_data = input_data.read()\\n PixelSizeX = input_data.transform[0]\\n PixelSizeY = -input_data.transform[4]\\n ###\\n nodata_value = input_data.nodata\\n ncols = input_data.width\\n nrows = input_data.height\\n shape = input_data.shape\\n ###\\n raster_pts = np.array(generate_raster_points(nrows, ncols, raw_data, nodata_value, PixelSizeX, PixelSizeY,0))\\n ### generate the simplified TIN\\n dt_2d = scipy.spatial.Delaunay([i[0:2] for i in pts_important])\\n ###now let's compare them\\n outlist = []\\n linelist = []\\n # print(ncols,nrows)\\n # print(shape)\\n # print(len(raster_pts))\\n # print(len(raw_data[0][1]))\\n col_counter = 0\\n row_counter = 0\\n for point in raster_pts:\\n if point[2] == nodata_value:\\n linelist.append(nodata_value)\\n else:\\n triangle_idx = dt_2d.find_simplex(point[0:2])\\n if triangle_idx == -1:\\n print(\\\"!!! WARNING: point outside convex hull of simplified dataset !!!\\\")\\n linelist.append(nodata_value)\\n else:\\n interpolation = TIN_interpolator(pts_important, dt_2d, triangle_idx, point)\\n linelist.append(point[2] - interpolation)\\n #index counters\\n col_counter +=1\\n if col_counter == ncols:\\n col_counter = 0\\n outlist.append(linelist)\\n linelist = []\\n #print(diff_raster)\\n #let's write the output file reusing the settings of the input file\\n outputter = rasterio.open(jparams[\\\"output-file-differences\\\"], 'w', **out_profile)\\n outputter.write(np.array([outlist]).astype(rasterio.float32))\\n \\n end = time.time()\\n print(\\\"compute_differences takes \\\",end - start)\",\n \"def make_diff(file_before, file_after, file_output_name):\\n if os.path.exists(file_output_name):\\n shutil.rmtree(file_output_name)\\n os.mkdir(file_output_name)\\n psd_diff = diff(file_before, file_after)\\n diff_content = {}\\n for attr in [\\\"header\\\", \\\"layer\\\"]:\\n diff_content[attr] = getattr(psd_diff, attr)\\n with open(os.path.join(file_output_name, \\\"diff.json\\\"), \\\"w\\\") as diff_file:\\n json.dump(diff_content, diff_file, indent=4)\\n saved_files = []\\n for layer_id in psd_diff.layer.keys():\\n if len(psd_diff.layer_image[layer_id]) > 1:\\n output_image = os.path.join(file_output_name, layer_id)\\n psd_diff.layer_image[layer_id][\\\"before\\\"].save(output_image + \\\".before.png\\\")\\n psd_diff.layer_image[layer_id][\\\"after\\\"].save(output_image + \\\".after.png\\\")\\n diff_image_before = Image.new(\\\"RGBA\\\", psd_diff.layer_image[layer_id][\\\"before\\\"].size)\\n diff_image_before_data = diff_image_before.load()\\n diff_image_after = Image.new(\\\"RGBA\\\", psd_diff.layer_image[layer_id][\\\"after\\\"].size)\\n diff_image_after_data = diff_image_after.load()\\n width, height = diff_image_before.size\\n pixel_index = 1\\n for y in xrange(height):\\n for x in xrange(width):\\n if str(pixel_index) in diff_content[\\\"layer\\\"][layer_id][\\\"pixel\\\"]:\\n diff_image_before_data[x, y] = tuple(diff_content[\\\"layer\\\"][layer_id][\\\"pixel\\\"][str(pixel_index)][\\\"before\\\"])\\n diff_image_after_data[x, y] = tuple(diff_content[\\\"layer\\\"][layer_id][\\\"pixel\\\"][str(pixel_index)][\\\"after\\\"])\\n else:\\n diff_image_before_data[x, y] = (0, 0, 0, 0)\\n diff_image_after_data[x, y] = (0, 0, 0, 0)\\n pixel_index += 1\\n diff_image_before.save(output_image + \\\".before.diff.png\\\", \\\"PNG\\\")\\n diff_image_after.save(output_image + \\\".after.diff.png\\\", \\\"PNG\\\")\\n saved_files.append(output_image + \\\".before.png\\\")\\n saved_files.append(output_image + \\\".before.diff.png\\\")\\n saved_files.append(output_image + \\\".after.diff.png\\\")\\n saved_files.append(output_image + \\\".after.png\\\")\\n saved_files.append(file_output_name + \\\"/diff.json\\\")\\n return saved_files\",\n \"def update_22(db, filename_persist, snapshots_dir, snapshots_reference_dir):\\n data = {\\n # 'fail'\\n 'test/test_pyglet_vb.py' : {\\n 'st': 'fail', 'diag': 'incomplete grossini rendition at first frame'},\\n\\n # 'error'\\n 'test/test_text_movement.py' : {\\n 'st': 'error',\\n 'diag': 'position should be set at the node level, not at the element level'},\\n\\n 'test/test_schedule_interval.py' : {\\n 'st':'error', 'diag': 'bad timestamps, repeated snapshots'},\\n\\n 'test/test_transitions_with_pop_recipe.py' : {\\n 'st':'error', 'diag': 'bad timestamps, repeated snapshots'},\\n\\n 'test/test_SequenceScene.py' : {\\n 'st':'error', 'diag': 'bad timestamps, black frame'},\\n\\n 'test/test_camera_orbit.py' : {\\n 'st':'error', 'diag': 'alternate snapshots are pure black'},\\n\\n 'test/test_jumptiles3d.py' : {\\n 'st':'error', 'diag': \\\"snpshots don't folow changes in scene\\\"},\\n\\n 'test/test_transition_zoom.py' : {\\n 'st':'error', 'diag': 'bad timestamps, repeated snapshots'},\\n }\\n\\n ren_key = {'st':'testrun_success', 'diag':'testrun_diagnostic'}\\n testrun_props_by_candidate = {}\\n for name in data:\\n testrun_props_by_candidate[name] = dict([(ren_key[k], data[name][k]) for k in data[name]])\\n \\n hl.update_testrun__bad(db, filename_persist, testrun_props_by_candidate,\\n snapshots_dir, snapshots_reference_dir)\",\n \"def update_alerts(self, source_path):\\n\\n read = 0\\n added = 0\\n errored = 0\\n now = Time.now().iso\\n\\n alerts_insert = '''\\n INSERT INTO alerts VALUES (\\n :nightid,last_insert_rowid(),:jd,:fid,:pid,:diffmaglim,\\n :pdiffimfilename,:programpi,:programid,:candid,\\n :isdiffpos,:tblid,:nid,:rcid,:field,:xpos,:ypos,\\n :ra,:dec,:magpsf,:sigmapsf,:chipsf,:magap,\\n :sigmagap,:distnr,:magnr,:sigmagnr,:chinr,\\n :sharpnr,:sky,:magdiff,:fwhm,:classtar,\\n :mindtoedge,:magfromlim,:seeratio,:aimage,:bimage,\\n :aimagerat,:bimagerat,:elong,:nneg,:nbad,:rb,\\n :ssdistnr,:ssmagnr,:ssnamenr,:sumrat,:magapbig,\\n :sigmagapbig,:ranr,:decnr,:sgmag1,:srmag1,:simag1,\\n :szmag1,:sgscore1,:distpsnr1,:ndethist,:ncovhist,\\n :jdstarthist,:jdendhist,:scorr,:tooflag,\\n :objectidps1,:objectidps2,:sgmag2,:srmag2,:simag2,\\n :szmag2,:sgscore2,:distpsnr2,:objectidps3,\\n :sgmag3,:srmag3,:simag3,:szmag3,:sgscore3,\\n :distpsnr3,:nmtchps,:rfid,:jdstartref,:jdendref,\\n :nframesref,:exptime)\\n '''\\n\\n tri = ProgressTriangle(1, self.logger, base=10)\\n for path, dirs, files in os.walk(source_path):\\n for f in files:\\n if not f.endswith('avro'):\\n continue\\n\\n read += 1\\n tri.update()\\n alert = util.avro2dict(os.path.join(path, f))\\n try:\\n candidate = alert['candidate']\\n except TypeError:\\n continue\\n\\n night = Time(candidate['jd'], format='jd').iso[:10]\\n\\n # exptime does not exist in older alerts\\n jd0 = candidate['jd']\\n jd1 = jd0 + candidate.get('exptime', 0)\\n candidate['exptime'] = candidate.get('exptime')\\n\\n try:\\n c = self.db.cursor()\\n c.execute('''\\n INSERT OR IGNORE INTO nights\\n VALUES (NULL,:date,0,:now)\\n ''', dict(date=night, now=now))\\n\\n candidate['nightid'] = c.execute('''\\n SELECT nightid FROM nights\\n WHERE date=:date\\n ''', dict(date=night)).fetchone()[0]\\n\\n ra = np.radians(candidate['ra'])\\n dec = np.radians(candidate['dec'])\\n points = util.define_points(ra, dec, HALF_SIZE)\\n rows = [[None, 'alerts', jd0, jd1, points]]\\n self.db.add_observations(\\n rows, other_cmd=alerts_insert,\\n other_rows=[candidate])\\n except sqlite3.IntegrityError:\\n errored += 1\\n continue\\n\\n c.execute('''\\n UPDATE nights SET alerts=alerts+1 WHERE date=:date\\n ''', dict(date=night))\\n \\n added += 1\\n\\n self.logger.info('{} files read, {} added to database.'\\n .format(read, added))\\n self.logger.warning('{} errored transactions.'.format(errored))\",\n \"def create_dicts_w_info(df,\\n table_visit_diff_string,\\n bad_records_string='num_bad_records'):\\n\\n hpos = df['src_hpo_id'].unique().tolist()\\n\\n site_dictionaries = {}\\n\\n for hpo in hpos:\\n sample_df = df.loc[df['src_hpo_id'] == hpo]\\n\\n sample_df.loc[\\\"Total\\\"] = sample_df.sum(numeric_only=True)\\n\\n hpo_dict = sample_df.loc[\\\"Total\\\"].to_dict()\\n\\n site_dictionaries[hpo] = hpo_dict\\n\\n tot = 0\\n\\n num_bad_records = {}\\n\\n for hpo, info in site_dictionaries.items():\\n num_bad_records[hpo] = info[bad_records_string]\\n\\n table_visit_diff_dict = {}\\n tot_rec, tot_diff = 0, 0\\n\\n for hpo, info in site_dictionaries.items():\\n bad_records = info[bad_records_string]\\n difference = info[table_visit_diff_string]\\n\\n tot_rec += bad_records\\n tot_diff += difference\\n\\n avg = round(difference / bad_records, 2)\\n\\n table_visit_diff_dict[hpo] = avg\\n\\n table_visit_diff_dict['Total'] = round(tot_diff / tot_rec, 2)\\n\\n return num_bad_records, table_visit_diff_dict\",\n \"def calculate_diagnostics(self):\\n\\n # create dictionary of lists of compartment values\\n self.population_soln = {}\\n for label in self.labels:\\n if label in self.population_soln:\\n continue\\n self.population_soln[label] = self.get_compartment_soln(label)\\n\\n # used as flag to build var_array after self.calculate_vars\\n # has been run\\n self.var_labels = None\\n\\n n_time = len(self.times)\\n for i in range(n_time):\\n\\n self.time = self.times[i]\\n\\n for label in self.labels:\\n self.compartments[label] = self.population_soln[label][i]\\n\\n self.calculate_vars()\\n self.calculate_flows()\\n self.calculate_diagnostic_vars()\\n\\n # only set after self.calculate_diagnostic_vars has been run so that we have all var_labels,\\n # including the ones in calculate_diagnostic_vars\\n if self.var_labels is None:\\n self.var_labels = list(self.vars.keys())\\n self.var_array = numpy.zeros((n_time, len(self.var_labels)))\\n self.flow_array = numpy.zeros((n_time, len(self.labels)))\\n\\n for i_label, label in enumerate(self.var_labels):\\n self.var_array[i, i_label] = self.vars[label]\\n for i_label, label in enumerate(self.labels):\\n self.flow_array[i, i_label] = self.flows[label]\\n\\n # calculate compartment sizes as fractions of population\\n self.fraction_soln = {}\\n for label in self.labels:\\n self.fraction_soln[label] = [\\n old_div(v,\\n t) for v,\\n t in zip(\\n self.population_soln[label],\\n self.get_var_soln('population'))\\n ]\",\n \"def test_migrate_interpretation_request_rd(self):\\n old_instance = GenericFactoryAvro.get_factory_avro(\\n self.old_model.InterpretationRequestRD, VERSION_300, fill_nullables=False\\n ).create() # reports_3_0_0.InterpretationRequestRD\\n self._validate(old_instance)\\n migrated_instance = MigrateReports3To4().migrate_interpretation_request_rd(old_instance=old_instance)\\n self._validate(migrated_instance)\\n\\n old_big_wigs = old_instance.bigWigs\\n new_big_wigs = migrated_instance.bigWigs\\n\\n if old_big_wigs is not None:\\n for old_big_wig, new_big_wig in zip(old_big_wigs, new_big_wigs):\\n self.assertIsInstance(new_big_wig, self.new_model.File)\\n self.assertEqual(new_big_wig.sampleId, old_big_wig.SampleId)\\n self.assertEqual(new_big_wig.uriFile, old_big_wig.URIFile)\\n self.assertEqual(new_big_wig.fileType, old_big_wig.fileType)\\n self.assertEqual(new_big_wig.md5Sum, None)\\n\\n old_instance = GenericFactoryAvro.get_factory_avro(\\n self.old_model.InterpretationRequestRD, VERSION_300, fill_nullables=True\\n ).create() # reports_3_0_0.InterpretationRequestRD\\n self._validate(old_instance)\\n migrated_instance = MigrateReports3To4().migrate_interpretation_request_rd(old_instance=old_instance)\\n\\n for old_variant, new_variant in zip(old_instance.TieredVariants, migrated_instance.tieredVariants):\\n for old_re, new_re in zip(old_variant.reportEvents, new_variant.reportEvents):\\n self.assertEqual(old_re.genomicFeature.HGNC, new_re.genomicFeature.hgnc)\\n\\n self._validate(migrated_instance)\",\n \"def calc_orig(self):\\n measure = self.measure\\n # Calculate work for all possible matching pairs from sim and obs\\n aw = np.full(shape=(len(self.q_obs), len(self.q_sim)), fill_value=np.nan)\\n # iterate through all flow observations\\n for i_o in range(len(self.q_obs)):\\n # Check only simulations within the allowed window\\n for i_s in range(max(0, i_o - self.max_lead),\\n min(len(self.q_sim), i_o + self.max_lag + 1)):\\n if measure in ('nse', 'square'):\\n aw[i_s, i_o] = (self.q_sim[i_s] - self.q_obs[i_o]) ** 2 + self.b ** 2 * (i_s - i_o) ** 2\\n elif measure in ('mae', 'abs'):\\n aw[i_s, i_o] = np.abs(self.q_sim[i_s] - self.q_obs[i_o]) + self.b * np.abs(i_s - i_o)\\n\\n # Calculate cumulative work along possible paths\\n cw = np.ones(shape=aw.shape + (2,)) * np.nan\\n # Populate first column\\n cw[:, 0, 0] = aw[:, 0]\\n\\n if self.keep_internals:\\n self.aw = aw\\n self.cw = cw\\n\\n # Populate other columns\\n # Filter out warning to suppress warnings from numpy when np.nanmin\\n # encounters all NaN slices\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n for i_o in range(1, aw.shape[1]):\\n for i_s in range(max(0, i_o - self.max_lead),\\n min(aw.shape[1], i_o + self.max_lag + 1)):\\n # e = aw[i_s, i_o]\\n if measure in ('nse', 'square'):\\n e = (self.q_sim[i_s] - self.q_obs[i_o]) ** 2 + self.b ** 2 * (i_s - i_o) ** 2\\n elif measure in ('mae', 'abs'):\\n e = np.abs(self.q_sim[i_s] - self.q_obs[i_o]) + self.b * np.abs(i_s - i_o)\\n\\n # Repeat the same simulation point\\n cw[i_s, i_o, 1] = e + cw[i_s, i_o - 1, 0]\\n\\n if i_s > 0:\\n m1 = np.nanmin(cw[i_s - 1, i_o - 1, :])\\n if i_s > 1:\\n # Skip a sim point\\n m2 = np.nanmin(cw[i_s - 2, i_o - 1, :])\\n else:\\n m2 = np.inf\\n m = min(m1, m2)\\n cw[i_s, i_o, 0] = e + m\\n self.opt_score = np.nanmin(cw[:, -1, :])\\n self.of = 1 - self.opt_score / self.fbench\\n\\n if self.calc_rays:\\n # self._do_calc_rays(cw[:, :, 0], cw[:, :, 1])\\n s, e = 0, None\\n for i_o in range(len(self.q_obs))[::-1]:\\n # print('')\\n # print(i_o, s, e)\\n # print(cw[s:e, i_o, 0])\\n m = np.nanargmin(cw[s:e, i_o, 0]) + s\\n try:\\n m_rep = np.nanargmin(cw[s:e, i_o, 1]) + s\\n except ValueError:\\n pass\\n else:\\n if cw[m_rep, i_o, 1] <= cw[m, i_o, 0]:\\n m = m_rep\\n self.tau[i_o] = i_o - m\\n self.res[i_o] = self.q_obs[i_o] - self.q_sim[m]\\n self.rays[i_o] = [(i_o, self.q_obs[i_o]), (m, self.q_sim[m])]\\n # print(i_o, s, e, m)\\n s, e = max(0, m - 2), m + 1\\n\\n return self.of\",\n \"def interpolate_loss_calculation(self, interpolates):\\n _, fake_scores = self.D(interpolates)\\n return fake_scores\",\n \"def calculate_flowamount_diff_between_dfs(dfa_load, dfb_load):\\n\\n # subset the dataframes, only keeping data for easy\\n # comparison of flowamounts\\n drop_cols = ['Year', 'MeasureofSpread', 'Spread', 'DistributionType',\\n 'Min', 'Max', 'DataReliability', 'DataCollection']\\n # drop cols and rename, ignore error if a df does not\\n # contain a column to drop\\n dfa = dfa_load.drop(drop_cols, axis=1, errors='ignore'\\n ).rename(columns={'FlowAmount': 'FlowAmount_Original'})\\n dfb = dfb_load.drop(drop_cols, axis=1, errors='ignore'\\n ).rename(columns={'FlowAmount': 'FlowAmount_Modified'})\\n # create df dict for modified dfs created in for loop\\n df_list = []\\n for d in ['a', 'b']:\\n df_name = f'df{d}'\\n # assign new column of geoscale by which to aggregate\\n vars()[df_name+'2'] = vars()[df_name].assign(\\n geoscale=np.where(vars()[df_name]['Location'].\\n apply(lambda x: x.endswith('000')),\\n 'state', 'county'))\\n vars()[df_name+'2'] = vars()[df_name+'2'].assign(\\n geoscale=np.where(vars()[df_name+'2']['Location'] == '00000',\\n 'national', vars()[df_name+'2']['geoscale']))\\n # ensure all nan/nones filled/match\\n vars()[df_name + '2'] = \\\\\\n replace_strings_with_NoneType(vars()[df_name+'2'])\\n df_list.append(vars()[df_name+'2'])\\n # merge the two dataframes\\n for df in df_list:\\n replace_NoneType_with_empty_cells(df)\\n df = df_list[0].merge(df_list[1], how='outer')\\n\\n # determine if any new data is negative\\n dfn = df[df['FlowAmount_Modified'] < 0].reset_index(drop=True)\\n if len(dfn) > 0:\\n vLog.info('There are negative FlowAmounts in new dataframe, '\\n 'see Validation Log')\\n vLogDetailed.info('Negative FlowAmounts in new dataframe: '\\n '\\\\n {}'.format(dfn.to_string()))\\n\\n # Because code will sometimes change terminology, aggregate\\n # data by context and flowable to compare df differences\\n # subset df\\n dfs = df[['Flowable', 'Context', 'ActivityProducedBy',\\n 'ActivityConsumedBy', 'FlowAmount_Original',\\n 'FlowAmount_Modified', 'Unit', 'geoscale']]\\n agg_cols = ['Flowable', 'Context', 'ActivityProducedBy',\\n 'ActivityConsumedBy', 'Unit', 'geoscale']\\n dfagg = dfs.groupby(\\n agg_cols, dropna=False, as_index=False).agg(\\n {'FlowAmount_Original': sum, 'FlowAmount_Modified': sum})\\n # column calculating difference\\n dfagg['FlowAmount_Difference'] = \\\\\\n dfagg['FlowAmount_Modified'] - dfagg['FlowAmount_Original']\\n dfagg['Percent_Difference'] = (dfagg['FlowAmount_Difference'] /\\n dfagg['FlowAmount_Original']) * 100\\n # drop rows where difference = 0\\n dfagg2 = dfagg[dfagg['FlowAmount_Difference'] != 0].reset_index(drop=True)\\n if len(dfagg2) == 0:\\n vLogDetailed.info('No FlowAmount differences')\\n else:\\n # subset df and aggregate, also print out the total\\n # aggregate diff at the geoscale\\n dfagg3 = replace_strings_with_NoneType(dfagg).drop(\\n columns=['ActivityProducedBy', 'ActivityConsumedBy',\\n 'FlowAmount_Difference', 'Percent_Difference'])\\n dfagg4 = dfagg3.groupby(\\n ['Flowable', 'Context', 'Unit', 'geoscale'],\\n dropna=False, as_index=False).agg(\\n {'FlowAmount_Original': sum, 'FlowAmount_Modified': sum})\\n # column calculating difference\\n dfagg4['FlowAmount_Difference'] = \\\\\\n dfagg4['FlowAmount_Modified'] - dfagg4['FlowAmount_Original']\\n dfagg4['Percent_Difference'] = (dfagg4['FlowAmount_Difference'] /\\n dfagg4['FlowAmount_Original']) * 100\\n # drop rows where difference = 0\\n dfagg5 = dfagg4[\\n dfagg4['FlowAmount_Difference'] != 0].reset_index(drop=True)\\n vLogDetailed.info('Total FlowAmount differences between dataframes: '\\n '\\\\n {}'.format(dfagg5.to_string(), index=False))\\n\\n # save detail output in log file\\n vLogDetailed.info('Total FlowAmount differences by Activity Columns: '\\n '\\\\n {}'.format(dfagg2.to_string(), index=False))\",\n \"def test_review_status_update_from_source_trim(self):\\n test_project_path = os.path.join(self.test_workspace,\\n 'review_status_files')\\n test_project_name = 'review_status_update_proj'\\n\\n plist_file = os.path.join(test_project_path, 'divide_zero.plist')\\n source_file = os.path.join(test_project_path, 'divide_zero.cpp')\\n plist_test.prefix_file_path(plist_file, test_project_path)\\n\\n codechecker_cfg = env.import_codechecker_cfg(self.test_workspace)\\n codechecker_cfg['reportdir'] = test_project_path\\n\\n codechecker.store(codechecker_cfg, test_project_name)\\n\\n codechecker_cfg['trim_path_prefix'] = test_project_path\\n\\n # Run data for the run created by this test case.\\n run_filter = RunFilter(names=[test_project_name], exactMatch=True)\\n\\n runs = self._cc_client.getRunData(run_filter, None, 0, None)\\n run = runs[0]\\n runid = run.runId\\n logging.debug('Get all run results from the db for runid: ' +\\n str(runid))\\n\\n reports = get_all_run_results(self._cc_client, runid)\\n self.assertIsNotNone(reports)\\n self.assertNotEqual(len(reports), 0)\\n self.assertEqual(len(reports), 2)\\n\\n for report in reports:\\n print(report)\\n self.assertEqual(report.reviewData.status,\\n ReviewStatus.INTENTIONAL)\\n\\n # Modify review comments from intentional to confirmed for the\\n # second store.\\n with open(source_file, 'r+', encoding='utf-8', errors='ignore') as sf:\\n content = sf.read()\\n new_content = content.replace(\\\"codechecker_intentional\\\",\\n \\\"codechecker_confirmed\\\")\\n sf.truncate(0)\\n sf.write(new_content)\\n\\n # modify review comments and store the reports again\\n with open(source_file, encoding='utf-8', errors='ignore') as sf:\\n content = sf.read()\\n\\n # Update the plist file modification date to be newer than\\n # the source file so it can be stored, because there was no\\n # actual analysis.\\n date = datetime.datetime.now() + datetime.timedelta(minutes=5)\\n mod_time = time.mktime(date.timetuple())\\n os.utime(plist_file, (mod_time, mod_time))\\n\\n codechecker.store(codechecker_cfg, test_project_name)\\n\\n # Check if all the review statuses were updated to the new at the\\n # server.\\n reports = get_all_run_results(self._cc_client, runid)\\n self.assertIsNotNone(reports)\\n self.assertNotEqual(len(reports), 0)\\n self.assertEqual(len(reports), 2)\\n for report in reports:\\n self.assertEqual(report.reviewData.status, ReviewStatus.CONFIRMED)\",\n \"def calculate_loss(estimated_separation, true_separation, mask, true_latents, estimated_mix, true_mix, args):\\n stats = torch.zeros(7)\\n sdr = sdr_objective(estimated_separation, true_separation, mask)\\n stats[:4] = sdr\\n total_loss = -sdr.sum()\\n reconstruction_sdr = sdr_objective(estimated_mix, true_mix).mean() if args.reconstruction_loss_weight > 0 else 0.0\\n stats[4] = reconstruction_sdr\\n total_loss += -args.reconstruction_loss_weight * reconstruction_sdr\\n if args.similarity_loss_weight > 0.0 or args.dissimilarity_loss_weight > 0.0:\\n mask = mask.squeeze(-1)\\n true_latents = true_latents * mask.unsqueeze(-1).unsqueeze(-1)\\n true_latents = true_latents.transpose(0, 1)\\n dissimilarity = dissimilarity_loss(true_latents, mask) if args.dissimilarity_loss_weight > 0.0 else 0.0\\n stats[5] = dissimilarity\\n total_loss += args.dissimilarity_loss_weight * dissimilarity\\n similarity = similarity_loss(true_latents, mask) if args.similarity_loss_weight > 0.0 else 0.0\\n stats[6] = similarity\\n total_loss += -args.similarity_loss_weight * similarity\\n return total_loss, stats\",\n \"def _collect_lines( self, diffs ):\\n\\n\\t\\tfromlist, tolist, flaglist = [], [], []\\n\\t\\t# pull from/to data and flags from mdiff style iterator\\n\\t\\tfor fromdata, todata, flag in diffs:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\t# store HTML markup of the lines into the lists\\n\\t\\t\\t\\tfromlist.append( self._format_line( 0, flag, *fromdata ) )\\n\\t\\t\\t\\ttolist.append( self._format_line( 1, flag, *todata ) )\\n\\t\\t\\texcept TypeError:\\n\\t\\t\\t\\t# exceptions occur for lines where context separators go\\n\\t\\t\\t\\tfromlist.append( None )\\n\\t\\t\\t\\ttolist.append( None )\\n\\t\\t\\tflaglist.append( flag )\\n\\t\\treturn fromlist, tolist, flaglist\",\n \"def check_paths(self):\\r\\n\\t\\tself.check_line_edits_and_refresh_filestate()\\r\\n\\t\\t# paths\\r\\n\\t\\tsource_img_filename = self.source_img_entry.text().replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\r\\n\\t\\tsink_dir_name = self.sink_dir_entry.text().replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\r\\n\\t\\tsink_db_name_entry_text = self.sink_db_name_entry.text()\\r\\n\\t\\tdb_ext = \\\".db\\\" if not sink_db_name_entry_text.lower().endswith(\\\".db\\\") else \\\"\\\"\\r\\n\\t\\tsink_db_filename = os.path.join(sink_dir_name, sink_db_name_entry_text + db_ext).replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\r\\n\\t\\tsource_db_filename = \\\"\\\"\\r\\n\\r\\n\\t\\t# check validity\\r\\n\\t\\tsource_img_filename_valid = self.filestate.is_valid(source_img_filename, SOURCE_IMG)\\r\\n\\t\\tsink_dir_name_valid = self.filestate.is_valid(sink_dir_name, SINK_DIR)\\r\\n\\t\\tsink_db_filename_valid = self.filestate.is_valid(sink_db_filename, SINK_DB)\\r\\n\\t\\tsource_db_filename_valid = True\\r\\n\\r\\n\\t\\tall_paths_valid = source_img_filename_valid and sink_dir_name_valid and sink_db_filename_valid\\r\\n\\r\\n\\t\\tif self.existing_case:\\r\\n\\t\\t\\tsource_db_filename = self.source_db_entry.text()\\r\\n\\t\\t\\tsource_db_filename_valid = self.filestate.is_valid(source_db_filename, SOURCE_DB)\\r\\n\\t\\t\\tall_paths_valid = all_paths_valid and source_db_filename_valid\\r\\n\\r\\n\\t\\tif all_paths_valid:\\r\\n\\t\\t\\tself.filestate.set_source_img_filename(source_img_filename)\\r\\n\\t\\t\\tself.filestate.set_sink_dir_name(sink_dir_name)\\r\\n\\t\\t\\tself.filestate.set_sink_db_filename(sink_db_filename)\\r\\n\\t\\t\\tif self.existing_case:\\r\\n\\t\\t\\t\\tself.filestate.set_source_db_filename(source_db_filename)\\r\\n\\t\\t\\tself.refresh_UI()\\r\\n\\t\\t\\treturn True\\r\\n\\r\\n\\t\\t# in the case of invalidity\\r\\n\\t\\tif not source_img_filename_valid:\\r\\n\\t\\t\\tif not self.filestate.source_img_file_exists:\\r\\n\\t\\t\\t\\tdisplay_warning_message(self, \\\"Provided source image file at does not exist.\\\")\\r\\n\\t\\t\\telif not self.filestate.source_img_file_format_valid:\\r\\n\\t\\t\\t\\tdisplay_warning_message(self, \\\"Provided source image file type is invalid (must be .npy).\\\")\\r\\n\\t\\t\\tself.filestate.set_source_img_filename(\\\"\\\")\\r\\n\\t\\tif not source_db_filename_valid: # only if existing case\\r\\n\\t\\t\\tif not self.source_db_file_exists:\\r\\n\\t\\t\\t\\tdisplay_warning_message(self, \\\"Provided source database file does not exist.\\\")\\r\\n\\t\\t\\telif not self.filestate.source_db_file_format_valid:\\r\\n\\t\\t\\t\\tdisplay_warning_message(self, \\\"Provided source database file type is invalid (must be .db)\\\")\\r\\n\\t\\t\\tself.filestate.set_source_db_filename(\\\"\\\")\\r\\n\\t\\tif not sink_dir_name_valid:\\r\\n\\t\\t\\tif not self.filestate.sink_dir_exists:\\r\\n\\t\\t\\t\\tdisplay_warning_message(self, \\\"Provided sink directory does not exist.\\\")\\r\\n\\t\\t\\telif not self.sink_dir_format_valid:\\r\\n\\t\\t\\t\\tdisplay_warning_message(self, \\\"Provided sink directory format is invalid.\\\")\\r\\n\\t\\t\\tself.filestate.set_sink_dir_name(\\\"\\\")\\r\\n\\t\\tif not sink_db_filename_valid:\\r\\n\\t\\t\\tif sink_dir_name_valid and not self.filestate.sink_db_file_preexists and \\\\\\r\\n\\t\\t\\t\\t\\tself.filestate.sink_db_file_format_valid and \\\\\\r\\n\\t\\t\\t\\t\\tdisplay_yes_no_message(self, \\\"Create file at \\\" + sink_db_filename + \\\"?\\\"):\\r\\n\\t\\t\\t\\t# create file with read write permissions\\r\\n\\t\\t\\t\\t###########################################\\r\\n\\t\\t\\t\\ttry:\\r\\n\\t\\t\\t\\t\\tsink_db_file = open(sink_db_filename, \\\"w+\\\")\\r\\n\\t\\t\\t\\t\\tsink_db_file.close()\\r\\n\\t\\t\\t\\texcept IOError as error:\\r\\n\\t\\t\\t\\t\\tdisplay_warning_message(self, \\\"Failed to create provided sink database file: \\\" + error)\\r\\n\\t\\t\\t\\t###########################################\\r\\n\\t\\t\\t\\t# set sink db filename\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tself.filestate.set_sink_db_filename(sink_db_filename)\\r\\n\\t\\t\\t\\t\\tself.refresh_UI()\\r\\n\\t\\t\\t\\t\\treturn True\\r\\n\\t\\t\\telif not self.filestate.sink_db_file_format_valid:\\r\\n\\t\\t\\t\\tdisplay_warning_message(self, \\\"Be sure to specify a name for the sink database.\\\")\\r\\n\\t\\t\\tself.filestate.set_sink_db_filename(\\\"\\\")\\r\\n\\r\\n\\t\\t# print(\\\"paths invalid\\\")\\r\\n\\t\\tself.refresh_UI()\\r\\n\\t\\treturn False\",\n \"def _abort_on_conflicting_untracked_paths(self) -> None:\\n repo = get_git_repo()\\n\\n if not repo or self._base_commit is None:\\n return\\n\\n changed_paths = set(\\n self._status.added\\n + self._status.modified\\n + self._status.removed\\n + self._status.unmerged\\n )\\n untracked_paths = {\\n self._fname_to_path(repo, str(path))\\n for path in (self._dirty_paths_by_status.get(StatusCode.Untracked, []))\\n }\\n overlapping_paths = untracked_paths & changed_paths\\n\\n if overlapping_paths:\\n raise ActionFailure(\\n \\\"Some paths that changed since the baseline commit now show up as untracked files. \\\"\\n f\\\"Please commit or stash your untracked changes in these paths: {overlapping_paths}.\\\"\\n )\",\n \"def __CompareText1(self, s1, s2,result):\\n # lines with tag that are excluded by hand (by the user) \\n s0_excluded=list()\\n for l0 in self.excluded_lines.splitlines():\\n s0_excluded.append(l0.strip()) \\n\\n s1_filtered=list()\\n s2_filtered=list() \\n for l1 in s1.splitlines(): \\n if l1.__contains__(self.stdout_tag): \\n check=0\\n for k in s0_excluded: \\n if l1.__contains__(k): check=check+1 \\n if check==0: s1_filtered.append(l1.strip())\\n for l2 in s2.splitlines(): \\n if l2.__contains__(self.stdout_tag): \\n check=0\\n for k in s0_excluded: \\n if l2.__contains__(k): check=check+1 \\n if check==0: s2_filtered.append(l2.strip())\\n # some debug: shows the lines which will be compared \\n mm=''\\n nTot=0\\n nDif=0\\n nMis=0\\n for l in range(max(len(s1_filtered),len(s2_filtered))): \\n nTot=nTot+1\\n if ( l>len(s1_filtered)-1 ): # ref[l] exists but log[l] does not\\n nMis=nMis+1\\n if ( nMis<=5 ) : # print only the first 5 missing lines\\n mm=mm+'\\\\n%5i'%l\\n if ( nMis<5 ) :\\n mm=mm+'-> log: ...MISSING('+repr(nMis)+')...'+'\\\\n' \\n else:\\n mm=mm+'-> log: ...MISSING(5)... SKIP THE REST'+'\\\\n' \\n if(l<=len(s2_filtered)-1):\\n mm=mm+' ref: '+s2_filtered[l]+'\\\\n'\\n else:\\n mm=mm+' ref: '+'\\\\n'\\n elif( l>len(s2_filtered)-1 or # log[l] exists but ref[l] does not\\n s1_filtered[l] != s2_filtered[l] ): # log[l] != ref[l]\\n nDif=nDif+1\\n mm=mm+'\\\\n%5i'%l\\n mm=mm+'-> log: '+s1_filtered[l]+'\\\\n'\\n if(l<=len(s2_filtered)-1):\\n mm=mm+' ref: '+s2_filtered[l]+'\\\\n' \\n else:\\n mm=mm+' ref: '+'\\\\n' \\n if(nDif>0 or nMis>0): mm=mm+'\\\\nSummary: '+repr(nDif)+' lines differ and '+repr(nMis)+' are missing out of '+repr(nTot)+' lines\\\\n'\\n result[\\\"ExecTest.stdout_VS_expected_stdout\\\"] = result.Quote(mm)\\n logger.debug('ExecTestBase2:__CompareTest1: '+mm) \\n # Comparision of filtered sets \\n # - filtered sets should have the same length: if this is not the \\n # case the test will stop here \\n if not(len(s1_filtered)==len(s2_filtered)): \\n self.causes.append(' Different number of tagged lines to compare \\\\n'+\\\\\\n 'in the stdout and ref_stdout')\\n return False \\n # Scan of the s1 and ref_s1=s2 looking for the '=' \\n s1_filtered_equals=list()\\n s2_filtered_equals=list() \\n for i in range(len(s1_filtered)):\\n if s1_filtered[i].__contains__('='):\\n s1_filtered_equals.append(s1_filtered[i].replace(\\\\\\n self.stdout_tag,'').strip())\\n if s2_filtered[i].__contains__('='):\\n s2_filtered_equals.append(s2_filtered[i].replace(\\\\\\n self.stdout_tag,'').strip()) \\n # - in case there is not '=' the strings have to be the same \\n if(not(s1_filtered[i].__contains__('=')) and \\n s2_filtered[i].__contains__('=')): return False \\n if(not(s1_filtered[i].__contains__('=')) and \\n not(s2_filtered[i].__contains__('=')) and \\n not(s1_filtered[i]==s2_filtered[i])): return False \\n\\n # Analysis of lines with '='\\n fail_cond=True \\n logger.debug('ExecTestBase2:__CompareTest1: # lines with = is '+\\\\\\n repr(len(s1_filtered_equals))) \\n for i in range(len(s1_filtered_equals)):\\n s1_split_list=s1_filtered_equals[i].split('=')\\n s2_split_list=s2_filtered_equals[i].split('=')\\n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\\\\n repr(i)+' are '+s1_split_list[1]+' '+s2_split_list[1])\\n # - No local tolerance marked with '+-' in the s2\\n if not(s2_split_list[1].__contains__('+-')):\\n try: # integer and float to float\\n s1_split_list_1=float(s1_split_list[1].strip())\\n s2_split_list_1=float(s2_split_list[1].strip())\\n # - comparison with global tolerance (if any) \\n if(s1_split_list_1!=0.): \\n if(not(s1_split_list[0]==s2_split_list[0]) or \\n not((s1_split_list_1==s2_split_list_1) or \\n ((s1_split_list_1<s2_split_list_1+\\\\\\n s2_split_list_1*float(self.stdout_tol)/100) and \\n (s1_split_list_1>s2_split_list_1-\\n s2_split_list_1*float(self.stdout_tol)/100))) \\n ): fail_cond=fail_cond and False \\n else: # case = 0 \\n if(not(s1_split_list[0]==s2_split_list[0]) or \\n not((s1_split_list_1==s2_split_list_1) or \\n ((s1_split_list_1<s2_split_list_1+\\\\\\n float(self.stdout_tol)/100) and \\n (s1_split_list_1>s2_split_list_1-\\n float(self.stdout_tol)/100))) \\n ): fail_cond=fail_cond and False \\n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\\\\n repr(i)+' are '+repr(s1_split_list_1)+' '+\\\\\\n repr(s2_split_list_1)+' with global tol (%) '+\\\\\\n repr(self.stdout_tol)+' '+repr(fail_cond) )\\n except: # strings\\n s1_split_list[1]=s1_split_list[1].strip() \\n s2_split_list[1]=s2_split_list[1].strip() \\n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\\\\n repr(i)+' are '+s1_split_list[1]+' '+\\\\\\n s2_split_list[1])\\n if(not(s1_split_list[0]==s2_split_list[0]) or \\n not(s1_split_list[1]==s2_split_list[1]) ): fail_cond=fail_cond and False \\n else: \\n # - comparison with local tolerance \\n print 'mgallas, to be done local tolerance'\\n return fail_cond\\n\\n for j in range(len(self.causes)):\\n print 'mgallas causes '+causes[j]\\n \\n return True\",\n \"def do_comparison(found_file, created_file):\\n\\n fh_f, fh_c, data_f, data_c = get_data(found_file, created_file)\\n\\n print('Initial found data shape ', data_f.shape)\\n print(' and created data shape= ', data_c.shape)\\n\\n # Compare slice i of created to slice i+1 in found\\n if (data_f.shape[0] == 1): # NIRCAM\\n data_f = data_f[0, :, :, :]\\n if (data_c.shape[0] == 1): # to accept output of mc_4d\\n data_c = data_c[0, :, :, :]\\n data_c_start = data_c[:-1, :, :]\\n data_f_end = data_f[1:, :, :]\\n elif (fh_f['SCI'].header['NAXIS'] == 3): # NIRSPEC\\n data_c_start = data_c[:-1, :, :]\\n data_f_end = data_f[1:, :, :]\\n elif (data_f.shape[0] > 1 and fh_f['SCI'].header['NAXIS'] == 4): # MIRI\\n # concatenate copies of created data (except for the last frame)\\n num_ints = int(fh_f[1].data.shape[0]) # number of integrations\\n data_c_start = (np.repeat(data_c[:-1, :, :], num_ints, axis=0))\\n data_f_end = data_f[:, 1:, :, :]\\n data_c_start = data_c_start.reshape(data_f_end.shape)\\n else:\\n print(' FATAL ERROR - unsupported instrument')\\n\\n print('Truncated found data shape ', data_f_end.shape)\\n print(' and truncated created data shape= ', data_c_start.shape)\\n try:\\n assert(data_f_end.shape == data_c_start.shape)\\n except AssertionError:\\n print(' FATAL ERROR: adjusted found data shape ', data_f.shape, \\\\\\n ' is not the same as adjusted created data shape= ', data_c.shape)\\n\\n neither = (data_c_start == 0.) & (data_f_end == 0.)\\n both = (data_c_start != 0.) & (data_f_end != 0.) # created CR was found\\n c_only = (data_c_start != 0.) & (data_f_end == 0.) # created CR not found\\n f_only = (data_c_start == 0.) & (data_f_end != 0.) # found CR was not created\\n\\n try:\\n assert(neither.sum() + both.sum() + c_only.sum() + f_only.sum() \\\\\\n == data_c_start.size)\\n except AssertionError:\\n print('FATAL ERROR: sum of components must equal total number of pixels ')\\n\\n print(' Within the input dataset cubes:')\\n print(' Number of created but not found pixels: ', c_only.sum())\\n print(' Number of found but not created pixels: ', f_only.sum())\\n print(' Number of pixels that are both found and created: ', both.sum())\\n print(' Number of pixels that are neither found nor created: ', neither.sum())\\n print(' ')\\n print(' The fraction of all pixels that were found only: ', \\\\\\n float(f_only.sum()) / float(data_c_start.size))\\n print(' The fraction of all pixels that were created only: ', \\\\\\n float(c_only.sum()) / float(data_c_start.size))\\n print(' The fraction of pixels in the created file having cosmic rays:', \\\\\\n float(c_only.sum()) / (data_c_start.shape[-2] * data_c_start.shape[-1]))\\n print(' ')\\n\\n write_files(neither, both, c_only, f_only, fh_c, data_c_start)\",\n \"def compute_diagnostics(self) -> Dict[str, Any]:\\n return {}\",\n \"def verbose_loss(self, feedback: _Feedback, extra_info) -> Dict[str, _Array]:\\n hint_preds, diff_logits, gt_diffs = extra_info\\n\\n for inp in feedback.features.inputs:\\n if inp.location in [_Location.NODE, _Location.EDGE]:\\n nb_nodes = inp.data.shape[1]\\n break\\n\\n total_loss = 0.0\\n lengths = feedback.features.lengths\\n\\n losses = {}\\n if self.decode_diffs:\\n for loc in _Location:\\n for i in range(len(gt_diffs)):\\n is_not_done = _is_not_done_broadcast(lengths, i, gt_diffs[i][loc])\\n diff_loss = (\\n jnp.maximum(diff_logits[i][loc], 0) -\\n diff_logits[i][loc] * gt_diffs[i][loc] +\\n jnp.log1p(jnp.exp(-jnp.abs(diff_logits[i][loc]))) * is_not_done)\\n losses[loc.name + '_diff_%d' % i] = jnp.mean(diff_loss)\\n\\n if self.decode_hints:\\n for truth in feedback.features.hints:\\n for i in range(truth.data.shape[0] - 1):\\n assert truth.name in hint_preds[i]\\n pred = hint_preds[i][truth.name]\\n is_not_done = _is_not_done_broadcast(lengths, i, truth.data[i + 1])\\n if truth.type_ == _Type.SCALAR:\\n if self.decode_diffs:\\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 *\\n gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 * is_not_done)\\n elif truth.type_ == _Type.MASK:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\\n jnp.log1p(jnp.exp(-jnp.abs(pred))) *\\n gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean(\\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\\n jnp.log1p(jnp.exp(-jnp.abs(pred))) * is_not_done)\\n elif truth.type_ == _Type.MASK_ONE:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n -jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred) * is_not_done, axis=-1, keepdims=True) *\\n gt_diffs[i][truth.location])\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred) * is_not_done, axis=-1))\\n elif truth.type_ == _Type.CATEGORICAL:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n -jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred), axis=-1, keepdims=True) *\\n jnp.expand_dims(gt_diffs[i][truth.location], -1) *\\n is_not_done)\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(pred), axis=-1) *\\n is_not_done)\\n elif truth.type_ == _Type.POINTER:\\n if self.decode_diffs:\\n total_loss = jnp.mean(-jnp.sum(\\n hk.one_hot(truth.data[i + 1], nb_nodes) *\\n jax.nn.log_softmax(pred),\\n axis=-1) * gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n hk.one_hot(truth.data[i + 1], nb_nodes) *\\n jax.nn.log_softmax(pred),\\n axis=-1) * is_not_done)\\n else:\\n raise ValueError('Incorrect type')\\n losses[truth.name + '_%d' % i] = total_loss\\n return losses\",\n \"def reconcile_with_destination(self, exception_cls=None, print_messages=None):\\n def print(*args, **kwargs):\\n if print_messages:\\n return __builtins__.print(*args, **kwargs)\\n try:\\n with pyodbc.connect(settings.LAB_IMPORT_DMIS_DATA_SOURCE) as cnxn:\\n with cnxn.cursor() as self.cursor:\\n for received_datetime, edc_specimen_identifier in self.received_items:\\n try:\\n packing_list_item = PackingListItem.objects.get(\\n item_reference=edc_specimen_identifier, received=False)\\n self.update_packing_list_item(packing_list_item, received_datetime)\\n print(edc_specimen_identifier + ' (received)')\\n except MultipleObjectsReturned:\\n for packing_list_item in PackingListItem.objects.filter(\\n item_reference=edc_specimen_identifier, received=False):\\n self.update_packing_list_item(packing_list_item, received_datetime)\\n print(edc_specimen_identifier + ' (received - dup)')\\n except PackingListItem.DoesNotExist:\\n pass\\n for received_datetime, edc_specimen_identifier, alpha_code in self.stored_items:\\n try:\\n packing_list_item = PackingListItem.objects.get(\\n item_reference=edc_specimen_identifier, received=False)\\n Aliquot.objects.get(\\n aliquot_identifier=edc_specimen_identifier, aliquot_type__alpha_code=alpha_code)\\n self.update_packing_list_item(packing_list_item, received_datetime)\\n print(edc_specimen_identifier + ' (received in storage)')\\n except MultipleObjectsReturned:\\n for packing_list_item in PackingListItem.objects.filter(\\n item_reference=edc_specimen_identifier, received=False):\\n self.update_packing_list_item(packing_list_item, received_datetime)\\n print(edc_specimen_identifier + ' (received in storage - dup)')\\n except PackingListItem.DoesNotExist:\\n pass\\n except Aliquot.DoesNotExist:\\n print(edc_specimen_identifier + ' Wrong specimen type. Got {}.'.format(alpha_code))\\n except pyodbc.Error as error:\\n if exception_cls:\\n raise exception_cls(str(error))\\n else:\\n raise\\n print('Received packing list items for {}:'.format(\\n site_mappers.get_current_mapper().map_area, PackingListItem.objects.filter(received=True).count()))\\n for panel in PackingListItem.objects.values('panel__name').filter(received=True).annotate(Count('panel')):\\n print('{}: {}'.format(panel.get('panel__name'), panel.get('panel__count')))\\n print('List of pending packing list items for {}:'.format(site_mappers.get_current_mapper().map_area))\\n for packing_list_item in PackingListItem.objects.filter(received=False).order_by('created'):\\n try:\\n item_datetime = packing_list_item.item_datetime.strftime('%Y-%m-%d')\\n except AttributeError:\\n item_datetime = None\\n try:\\n panel_name = packing_list_item.panel.name.replace(' ', '_')\\n except AttributeError:\\n panel_name = None\\n print('{} {} pending {} {}'.format(\\n packing_list_item.item_reference,\\n packing_list_item.packing_list.timestamp,\\n item_datetime,\\n panel_name,\\n ))\",\n \"def test_with_known_snapping_error_data():\\n linestrings_loaded = (\\n samples.results_in_non_simple_from_branches_and_nodes_linestring_list\\n )\\n linestrings = [ls for ls in linestrings_loaded if isinstance(ls, LineString)]\\n assert len(linestrings_loaded) == len(linestrings)\\n result, any_changed_applied = branches_and_nodes.snap_traces(\\n linestrings, tests.snap_threshold\\n )\\n count = 0\\n while any_changed_applied:\\n result, any_changed_applied = branches_and_nodes.snap_traces(\\n result, tests.snap_threshold\\n )\\n count += 1\\n if count > 10:\\n raise RecursionError(\\\"Expected count to stay under 11.\\\")\\n\\n for ls in result:\\n assert ls.is_simple\\n assert isinstance(ls, LineString)\",\n \"def render_diff_report():\\n if nori.core.cfg['action'] == 'diff':\\n diff_report = ' Diff Report '\\n elif nori.core.cfg['action'] == 'sync':\\n diff_report = ' Diff / Sync Report '\\n diff_report = ('#' * len(diff_report) + '\\\\n' +\\n diff_report + '\\\\n' +\\n '#' * len(diff_report) + '\\\\n\\\\n')\\n if nori.core.cfg['report_order'] == 'template':\\n for template_index in diff_dict:\\n template = nori.core.cfg['templates'][template_index]\\n section_header = ('Template {0} ({1}):' .\\n format(template_index,\\n nori.pps(template[T_NAME_KEY])))\\n section_header += '\\\\n' + ('-' * len(section_header)) + '\\\\n\\\\n'\\n diff_report += section_header\\n for diff_t in diff_dict[template_index]:\\n exists_in_source = diff_t[0]\\n source_row = diff_t[1]\\n exists_in_dest = diff_t[2]\\n dest_row = diff_t[3]\\n has_been_changed = diff_t[4]\\n if exists_in_source:\\n source_str = nori.pps(source_row[1])\\n elif exists_in_source is None:\\n source_str = '[no value match in source database]'\\n else:\\n source_str = '[no key match in source database]'\\n if exists_in_dest:\\n dest_str = nori.pps(dest_row[1])\\n elif exists_in_dest is None:\\n dest_str = '[no value match in destination database]'\\n else:\\n dest_str = '[no key match in destination database]'\\n if has_been_changed is None:\\n changed_str = 'unchanged'\\n elif not has_been_changed:\\n changed_str = (\\n 'partially changed - action may be needed!'\\n )\\n else:\\n changed_str = 'changed'\\n diff_report += (\\n 'Source: {0}\\\\nDest: {1}\\\\nStatus: {2}\\\\n\\\\n' .\\n format(source_str, dest_str, changed_str)\\n )\\n diff_report += '\\\\n'\\n elif nori.core.cfg['report_order'] == 'keys':\\n for key_str in diff_dict:\\n section_header = ('Key tuple {0}:' .\\n format(nori.pps(key_str)))\\n section_header += '\\\\n' + ('-' * len(section_header)) + '\\\\n\\\\n'\\n diff_report += section_header\\n for diff_t in diff_dict[key_str]:\\n template_index = diff_t[0]\\n exists_in_source = diff_t[1]\\n source_row = diff_t[2]\\n exists_in_dest = diff_t[3]\\n dest_row = diff_t[4]\\n has_been_changed = diff_t[5]\\n template = nori.core.cfg['templates'][template_index]\\n if exists_in_source:\\n num_keys = source_row[0]\\n source_data = source_row[1]\\n source_str = nori.pps(source_data[num_keys:])\\n elif exists_in_source is None:\\n source_str = '[no value match in source database]'\\n else:\\n source_str = '[no key match in source database]'\\n if exists_in_dest:\\n num_keys = dest_row[0]\\n dest_data = dest_row[1]\\n dest_str = nori.pps(dest_data[num_keys:])\\n elif exists_in_dest is None:\\n dest_str = '[no value match in destination database]'\\n else:\\n dest_str = '[no key match in destination database]'\\n if has_been_changed is None:\\n changed_str = 'unchanged'\\n elif not has_been_changed:\\n changed_str = (\\n 'partially changed - action may be needed!'\\n )\\n else:\\n changed_str = 'changed'\\n diff_report += (\\n 'Template: {0}\\\\nSource: {1}\\\\nDest: {2}\\\\n'\\n 'Status: {3}\\\\n\\\\n' .\\n format(template[T_NAME_KEY], source_str, dest_str,\\n changed_str)\\n )\\n diff_report += '\\\\n'\\n return diff_report.strip()\",\n \"def analyze_thresholds(datapath, threshold_lt1, threshold_lt2, normalize = True, save = 1):\\n print 'analyzing thresholds...' \\n current_dir = os.getcwd()\\n os.chdir(datapath)\\n files = os.listdir(datapath)\\n\\n for k in arange(len(files)):\\n right_file = '.npz' in files[k]\\n \\n if right_file:\\n data = numpy.load(datapath+'\\\\\\\\'+files[k])\\n \\n CR_cts_after_seq_lt1 = data['cr_hist_LT1_first']\\n CR_cts_after_seq_lt2 = data['cr_hist_LT2_first']\\n\\n nr_of_counts = arange(len(CR_cts_after_seq_lt1))\\n\\n CR_cts_total_lt1 = data['cr_hist_LT1_total']\\n CR_cts_total_lt2 = data['cr_hist_LT2_total']\\n \\n if normalize:\\n CR_cts_after_seq_lt2 = CR_cts_after_seq_lt2/float(sum(CR_cts_after_seq_lt2))\\n CR_cts_total_lt2 = CR_cts_total_lt2/float(sum(CR_cts_total_lt2))\\n times_passed_after_seq_lt2 = CR_cts_after_seq_lt2[nr_of_counts>=threshold_lt2].sum()*100\\n times_passed_overall_lt2 = CR_cts_total_lt2[nr_of_counts>=threshold_lt2].sum()*100\\n \\n CR_cts_after_seq_lt1 = CR_cts_after_seq_lt1/float(sum(CR_cts_after_seq_lt1))\\n CR_cts_total_lt1 = CR_cts_total_lt1/float(sum(CR_cts_total_lt1))\\n times_passed_after_seq_lt1 = CR_cts_after_seq_lt1[nr_of_counts>=threshold_lt1].sum()*100\\n times_passed_overall_lt1 = CR_cts_total_lt1[nr_of_counts>=threshold_lt1].sum()*100\\n else:\\n times_passed_after_seq_lt2 = CR_cts_after_seq_lt2[nr_of_counts>=threshold_lt2].sum()/float(CR_cts_after_seq_lt2.sum())*100\\n times_passed_overall_lt2 = CR_cts_total_lt2[nr_of_counts>=threshold_lt2].sum()/float(CR_cts_total_lt2.sum())*100\\n times_passed_after_seq_lt1 = CR_cts_after_seq_lt1[nr_of_counts>=threshold_lt1].sum()*100/float(CR_cts_after_seq_lt1.sum())\\n times_passed_overall_lt1 = CR_cts_total_lt1[nr_of_counts>=threshold_lt1].sum()*100/float(CR_cts_total_lt1.sum())\\n\\n\\n #print 'After sequence: LT2 percentage passed = ',num2str(sum(times_passed_after_seq_lt2),1),'%'\\n #print 'and LT1 percentage passed = ',num2str(sum(times_passed_after_seq_lt1),1),'%'\\n\\n Log = False\\n\\n figure6 = plt.figure(figsize=(16.0, 12.0))\\n plt.subplot(223)\\n plt.bar(nr_of_counts,CR_cts_after_seq_lt2,log=Log, color = 'm')\\n plt.xlabel('Number of counts')\\n plt.ylabel('Fraction of occurrences')\\n if normalize:\\n plt.title('LT2: CR counts after sequence, passed threshold: '+num2str(times_passed_after_seq_lt2,1)+'%')\\n else:\\n plt.title('CR counts after sequence')\\n plt.xlim(0,25)\\n \\n plt.subplot(224)\\n plt.bar(nr_of_counts,CR_cts_total_lt2,log=Log, color = 'm')\\n plt.xlabel('Number of counts')\\n plt.ylabel('Fraction of occurrences')\\n if normalize:\\n plt.title('LT2: all CR checks, passed threshold: '+num2str(times_passed_overall_lt2,1)+'%')\\n else:\\n plt.title('CR counts for all CR checks')\\n plt.xlim(0,25)\\n\\n plt.subplot(221)\\n plt.bar(nr_of_counts,CR_cts_after_seq_lt1,log=Log, color = 'b')\\n plt.xlabel('Number of counts')\\n plt.ylabel('Fraction of occurrences')\\n if normalize:\\n plt.title('LT1: CR counts after sequence, passed threshold: '+num2str(times_passed_after_seq_lt1,1)+'%')\\n else:\\n plt.title('CR counts after sequence')\\n plt.xlim(0,50)\\n \\n plt.subplot(222)\\n plt.bar(nr_of_counts,CR_cts_total_lt1,log=Log, color = 'b')\\n plt.xlabel('Number of counts')\\n plt.ylabel('Fraction of occurrences')\\n if normalize:\\n plt.title('LT1: all CR checks, passed threshold: '+num2str(times_passed_overall_lt1,1)+'%')\\n else:\\n plt.title('CR counts for all CR checks')\\n plt.xlim(0,50)\\n \\n if save:\\n if normalize:\\n figure6.savefig('CR_information_LT1_and_LT2_normalized.pdf')\\n else:\\n figure6.savefig('CR_information_LT1_and_LT2.pdf')\\n\\n\\n return times_passed_overall_lt1, times_passed_after_seq_lt1, times_passed_overall_lt2, times_passed_after_seq_lt2\",\n \"def dataframe_difference(df_from_nerc,df_from_pangea):\\n if len(df_from_nerc)!=0: # nothing to insert or update if df_from_nerc is empty\\n not_in_database=[\\n df_from_nerc.iloc[i]['semantic_uri'] \\n not in df_from_pangea['semantic_uri'].values \\n for i in range(len(df_from_nerc))\\n ] \\n df_from_nerc['action']= np.where(not_in_database ,'insert', '') # if there are different elements we always have to insert them\\n df_insert=df_from_nerc[df_from_nerc['action']=='insert']\\n if len(df_insert)==0:\\n df_insert=None\\n ## update cond\\n if len(df_from_pangea)!=0: # nothing to update if df_from_pangea(pangaea db) is empty\\n in_database=np.invert(not_in_database)\\n df_from_nerc_in_database=df_from_nerc[in_database] \\n # create Timestamp lists with times of corresponding elements in df_from_nerc and df_from_pangea //corresponding elements chosen by semanntic_uri\\n df_from_nerc_in_database_T=[\\n df_from_nerc_in_database[df_from_nerc_in_database['semantic_uri']==s_uri]['datetime_last_harvest'].iloc[0] \\n for s_uri in df_from_nerc_in_database['semantic_uri']\\n ]\\n df_from_pangea_T=[\\n df_from_pangea[df_from_pangea['semantic_uri']==s_uri]['datetime_last_harvest'].iloc[0] \\n for s_uri in df_from_nerc_in_database['semantic_uri']\\n ]\\n # create list of booleans (condition for outdated elements)\\n df_from_nerc_in_database_outdated=[df_from_nerc_in_database_T[i]>df_from_pangea_T[i] for i in range(len(df_from_nerc_in_database_T))]\\n df_from_nerc_in_database=df_from_nerc_in_database.assign(action= np.where(df_from_nerc_in_database_outdated ,'update', ''))\\n df_update=df_from_nerc_in_database[df_from_nerc_in_database['action']=='update']\\n if len(df_update)==0: # make sure not to return empty dataframes! \\n df_update=None\\n else:\\n df_update=None\\n \\n return df_insert,df_update\\n \\n else:\\n df_insert,df_update=None,None\\n \\n return df_insert,df_update #df_insert/df_update.shape=(n,7) only 7 initial columns!\",\n \"def _state_diff(\\n old_state: State, new_state: State\\n) -> dict[str, dict[str, dict[str, dict[str, str | list[str]]]]]:\\n additions: dict[str, Any] = {}\\n diff: dict[str, dict[str, Any]] = {STATE_DIFF_ADDITIONS: additions}\\n new_state_context = new_state.context\\n old_state_context = old_state.context\\n if old_state.state != new_state.state:\\n additions[COMPRESSED_STATE_STATE] = new_state.state\\n if old_state.last_changed != new_state.last_changed:\\n additions[COMPRESSED_STATE_LAST_CHANGED] = new_state.last_changed.timestamp()\\n elif old_state.last_updated != new_state.last_updated:\\n additions[COMPRESSED_STATE_LAST_UPDATED] = new_state.last_updated.timestamp()\\n if old_state_context.parent_id != new_state_context.parent_id:\\n additions[COMPRESSED_STATE_CONTEXT] = {\\\"parent_id\\\": new_state_context.parent_id}\\n if old_state_context.user_id != new_state_context.user_id:\\n if COMPRESSED_STATE_CONTEXT in additions:\\n additions[COMPRESSED_STATE_CONTEXT][\\\"user_id\\\"] = new_state_context.user_id\\n else:\\n additions[COMPRESSED_STATE_CONTEXT] = {\\\"user_id\\\": new_state_context.user_id}\\n if old_state_context.id != new_state_context.id:\\n if COMPRESSED_STATE_CONTEXT in additions:\\n additions[COMPRESSED_STATE_CONTEXT][\\\"id\\\"] = new_state_context.id\\n else:\\n additions[COMPRESSED_STATE_CONTEXT] = new_state_context.id\\n if (old_attributes := old_state.attributes) != (\\n new_attributes := new_state.attributes\\n ):\\n for key, value in new_attributes.items():\\n if old_attributes.get(key) != value:\\n additions.setdefault(COMPRESSED_STATE_ATTRIBUTES, {})[key] = value\\n if removed := set(old_attributes).difference(new_attributes):\\n # sets are not JSON serializable by default so we convert to list\\n # here if there are any values to avoid jumping into the json_encoder_default\\n # for every state diff with a removed attribute\\n diff[STATE_DIFF_REMOVALS] = {COMPRESSED_STATE_ATTRIBUTES: list(removed)}\\n return {ENTITY_EVENT_CHANGE: {new_state.entity_id: diff}}\",\n \"def _consolidate_spont_results(self):\\n\\n # SPONT vs. SPONT\\n\\n # 1) deal with numeric results for spont spont\\n df = self.numeric_results.copy()\\n mean_cols = [c for c in df.columns if '_sem' not in c]\\n err_cols = [c for c in df.columns if '_sem' in c]\\n\\n spont_spont_mean = df.loc[pd.IndexSlice[self.spont_stimulus_pairs, :], :][mean_cols].groupby(by='n_components').mean()\\n spont_spont_sem = df.loc[pd.IndexSlice[self.spont_stimulus_pairs, :], :][err_cols].groupby(by='n_components').apply(error_prop)\\n spont_spont = pd.concat([spont_spont_mean, spont_spont_sem], axis=1)\\n new_idx = pd.MultiIndex.from_tuples([pd.Categorical(('spont_spont', n_components)) \\n for n_components in spont_spont.index], names=['combo', 'n_components'])\\n spont_spont.set_index(new_idx, inplace=True)\\n\\n # drop individual spont_spont pairs from master df\\n df = df[~df.index.get_level_values('combo').isin(self.spont_stimulus_pairs)]\\n\\n # add new spont results to df\\n df = spont_spont.append(df)\\n self.numeric_results = df.copy()\\n\\n\\n # 2) deal with array results for spont_spont\\n for obj in self.object_keys:\\n df = self.array_results[obj].copy()\\n sp_df = df.loc[pd.IndexSlice[self.spont_stimulus_pairs, :], :]\\n\\n if 'evecs' in obj:\\n m = [np.nanmean(reflect_eigenvectors(x), axis=0) for x in [np.stack([a for a in arr[1]['mean'].values]) for arr in sp_df.groupby('n_components')]]\\n sem = [error_prop(x, axis=0) for x in [np.stack([a for a in arr[1]['sem'].values]) for arr in sp_df.groupby('n_components')]]\\n else:\\n m = [np.nanmean(x, axis=0) for x in [np.stack([a for a in arr[1]['mean'].values]) for arr in sp_df.groupby('n_components')]]\\n sem = [error_prop(x, axis=0) for x in [np.stack([a for a in arr[1]['sem'].values]) for arr in sp_df.groupby('n_components')]]\\n \\n components = [arr[0] for arr in sp_df.groupby('n_components')]\\n new_idx = pd.MultiIndex.from_tuples([pd.Categorical(('spont_spont', n_components)) \\n for n_components in components], names=['combo', 'n_components'])\\n new_df = pd.DataFrame(index=new_idx, columns=['mean', 'sem'])\\n new_df['mean'] = m\\n new_df['sem'] = sem\\n\\n df = df[~df.index.get_level_values('combo').isin(self.spont_stimulus_pairs)]\\n df = new_df.append(df)\\n \\n self.array_results[obj] = df.copy()\\n\\n self.spont_stimulus_pairs = ['spont_spont']\\n\\n\\n # SPONT vs. EVOKED\\n df = self.numeric_results.copy()\\n unique_evoked_bins = np.unique([[c.split('_')[0], c.split('_')[1]] for c in self.evoked_stimulus_pairs])\\n\\n # 1) deal with numeric results\\n new_sp_ev_pairs = []\\n for stim in unique_evoked_bins:\\n # get all spont / evoked combos\\n sp_ev = np.unique([c for c in self.spont_evoked_stimulus_pairs if stim in c])\\n m = df.loc[pd.IndexSlice[sp_ev, :], :][mean_cols].groupby(by='n_components').mean()\\n sem = df.loc[pd.IndexSlice[sp_ev, :], :][err_cols].groupby(by='n_components').apply(error_prop)\\n sp_ev_df = pd.concat([m, sem], axis=1)\\n new_idx = pd.MultiIndex.from_tuples([pd.Categorical(('spont_{}'.format(stim), n_components)) \\n for n_components in sp_ev_df.index], names=['combo', 'n_components']) \\n sp_ev_df.set_index(new_idx, inplace=True)\\n df = sp_ev_df.append(df)\\n new_sp_ev_pairs.append('spont_{}'.format(stim))\\n\\n # remove inividual spont_evoked pairs \\n df = df[~df.index.get_level_values('combo').isin(self.spont_evoked_stimulus_pairs)] \\n\\n # save updated dataframe for numeric results\\n self.numeric_results = df.copy()\\n\\n # 2) deal with object results\\n for obj in self.object_keys:\\n df = self.array_results[obj].copy()\\n for stim in unique_evoked_bins:\\n sp_ev = np.unique([c for c in self.spont_evoked_stimulus_pairs if stim in c])\\n sp_df = df.loc[pd.IndexSlice[sp_ev, :], :]\\n\\n if 'evecs' in obj:\\n m = [np.nanmean(reflect_eigenvectors(x), axis=0) for x in [np.stack([a for a in arr[1]['mean'].values]) for arr in sp_df.groupby('n_components')]]\\n sem = [error_prop(x, axis=0) for x in [np.stack([a for a in arr[1]['sem'].values]) for arr in sp_df.groupby('n_components')]]\\n else:\\n m = [np.nanmean(x, axis=0) for x in [np.stack([a for a in arr[1]['mean'].values]) for arr in sp_df.groupby('n_components')]]\\n sem = [error_prop(x, axis=0) for x in [np.stack([a for a in arr[1]['sem'].values]) for arr in sp_df.groupby('n_components')]]\\n components = [arr[0] for arr in sp_df.groupby('n_components')]\\n new_idx = pd.MultiIndex.from_tuples([pd.Categorical(('spont_{}'.format(stim), n_components)) \\n for n_components in components], names=['combo', 'n_components'])\\n new_df = pd.DataFrame(index=new_idx, columns=['mean', 'sem'])\\n new_df['mean'] = m\\n new_df['sem'] = sem\\n\\n df = df[~df.index.get_level_values('combo').isin(self.spont_evoked_stimulus_pairs)]\\n df = new_df.append(df)\\n self.array_results[obj] = df\\n\\n # update self.spont_evoked_stimulus_pairs\\n self.spont_evoked_stimulus_pairs = new_sp_ev_pairs \\n\\n # no need to return anything... just update object attributes\",\n \"def run(self):\\n try:\\n diff = self.get_diff(self.diff_id)\\n revision = self.get_revision(diff.revisionID)\\n url = f\\\"https://reviews.llvm.org/D{revision['id']}?id={diff['id']}\\\"\\n annotate(f\\\"Patching changes [{url}]({url})\\\", style='info', context='patch_diff')\\n self.reset_repository()\\n self.revision_id = revision['id']\\n dependencies = self.get_dependencies(revision)\\n dependencies.reverse() # Now revisions will be from oldest to newest.\\n if len(dependencies) > 0:\\n logging.info('This diff depends on: {}'.format(revision_list_to_str(dependencies)))\\n plan = []\\n for r in dependencies:\\n if r['statusName'] == 'Closed':\\n logging.info(f'skipping revision {r[\\\"id\\\"]} - it is closed, assuming it has landed')\\n continue\\n d = self.get_diff(r['diffs'][0])\\n plan.append((r, d))\\n plan.append((revision, diff))\\n logging.info('Planning to apply in order:')\\n for (r, d) in plan:\\n logging.info(f\\\"https://reviews.llvm.org/D{r['id']}?id={d['id']}\\\")\\n # Pick the newest known commit as a base for patches.\\n base_commit = None\\n for (r, d) in plan:\\n c = self.find_commit(d['sourceControlBaseRevision'])\\n if c is None:\\n logging.warning(f\\\"D{r['id']}#{d['id']} commit {d['sourceControlBaseRevision']} does not exist\\\")\\n continue\\n if base_commit is None:\\n logging.info(f\\\"D{r['id']}#{d['id']} commit {c.hexsha} exists\\\")\\n base_commit = c\\n elif c.committed_datetime > base_commit.committed_datetime:\\n logging.info(f\\\"D{r['id']}#{d['id']} commit {c.hexsha} has a later commit date then\\\"\\n f\\\"{base_commit.hexsha}\\\")\\n base_commit = c\\n if self.base_revision != 'auto':\\n logging.info(f'Base revision \\\"{self.base_revision}\\\" is set by command argument. Will use '\\n f'instead of resolved \\\"{base_commit}\\\"')\\n base_commit = self.find_commit(self.base_revision)\\n if base_commit is None:\\n base_commit = self.repo.heads['main'].commit\\n annotate(f\\\"Cannot find a base git revision. Will use current HEAD.\\\",\\n style='warning', context='patch_diff')\\n self.create_branch(base_commit)\\n for (r, d) in plan:\\n if not self.apply_diff(d, r):\\n return 1\\n if self.push_branch:\\n self.repo.git.push('--force', 'origin', self.branch_name)\\n annotate(f\\\"Created branch [{self.branch_name}]\\\"\\n f\\\"(https://github.com/llvm-premerge-tests/llvm-project/tree/{self.branch_name}).\\\\n\\\\n\\\"\\n f\\\"To checkout locally, run in your copy of llvm-project directory:\\\\n\\\\n\\\"\\n \\\"```shell\\\\n\\\"\\n \\\"git remote add premerge git@github.com:llvm-premerge-tests/llvm-project.git #first time\\\\n\\\"\\n f\\\"git fetch premerge {self.branch_name}\\\\n\\\"\\n f\\\"git checkout -b {self.branch_name} --track premerge/{self.branch_name}\\\\n\\\"\\n \\\"```\\\",\\n style='success',\\n context='patch_diff')\\n logging.info('Branch {} has been pushed'.format(self.branch_name))\\n return 0\\n except Exception as e:\\n annotate(f\\\":bk-status-failed: Unexpected error. Consider [creating a bug]({feedback_url()}).\\\",\\n style='error', context='patch_diff')\\n logging.error(f'exception: {e}')\\n return 1\",\n \"def svn_client_diff_summarize2(char_path1, svn_opt_revision_t_revision1, char_path2, svn_opt_revision_t_revision2, svn_depth_t_depth, svn_boolean_t_ignore_ancestry, apr_array_header_t_changelists, svn_client_diff_summarize_func_t_summarize_func, void_summarize_baton, svn_client_ctx_t_ctx, apr_pool_t_pool): # real signature unknown; restored from __doc__\\n pass\",\n \"def compute_feedback_gradients(self, h_previous_corrupted, sigma):\\n\\n self.set_feedback_requires_grad(True)\\n\\n h_current = self.dummy_forward(h_previous_corrupted)\\n h = self.propagate_backward(h_current)\\n\\n if sigma < 0.02:\\n scale = 1/0.02**2\\n else:\\n scale = 1/sigma**2\\n reconstruction_loss = scale * F.mse_loss(h, h_previous_corrupted)\\n\\n self.save_feedback_gradients(reconstruction_loss)\\n\\n self.set_feedback_requires_grad(False)\",\n \"def calculate_loss(estimated_separation, true_separation, mask, true_latents, estimated_mix, true_mix, args):\\n stats = torch.zeros(7).to(mask.device)\\n\\n sdr = sdr_objective(estimated_separation, true_separation, mask)\\n stats[:4] = sdr\\n total_loss = -sdr.sum()\\n\\n reconstruction_sdr = sdr_objective(estimated_mix, true_mix).mean() if args.reconstruction_loss_weight > 0 else 0.0\\n stats[4] = reconstruction_sdr\\n total_loss += -args.reconstruction_loss_weight * reconstruction_sdr\\n\\n if args.similarity_loss_weight > 0.0 or args.dissimilarity_loss_weight > 0.0:\\n mask = mask.squeeze(-1)\\n true_latents = true_latents * mask.unsqueeze(-1).unsqueeze(-1)\\n true_latents = true_latents.transpose(0, 1)\\n\\n dissimilarity = dissimilarity_loss(true_latents, mask) if args.dissimilarity_loss_weight > 0.0 else 0.0\\n stats[5] = dissimilarity\\n total_loss += args.dissimilarity_loss_weight * dissimilarity\\n\\n similarity = similarity_loss(true_latents, mask) if args.similarity_loss_weight > 0.0 else 0.0\\n stats[6] = similarity\\n total_loss += -args.similarity_loss_weight * similarity\\n\\n return total_loss, stats\",\n \"def print_diff_summary(self, other, **kwargs):\\r\\n\\r\\n def diff_dict(a_time, b_time_):\\r\\n r = {}\\r\\n b_time = copy.copy(b_time_)\\r\\n for a, ta in a_time.items():\\r\\n r.setdefault(a, 0)\\r\\n tb = b_time.pop(a, 0)\\r\\n r[a] += ta - tb\\r\\n\\r\\n #they are missing in a\\r\\n for a, t in b_time.items():\\r\\n r.setdefault(a, 0)\\r\\n r[a] += t\\r\\n return r\\r\\n\\r\\n compile_time = self.compile_time - other.compile_time\\r\\n fct_call_time = diff_dict(self.fct_call_time, other.fct_call_time)\\r\\n fct_call = diff_dict(self.fct_call, other.fct_call)\\r\\n apply_time = diff_dict(self.apply_time, other.apply_time)\\r\\n apply_cimpl = self.apply_cimpl and other.apply_cimpl\\r\\n message = self.message\\r\\n variable_shape = diff_dict(self.variable_shape, other.variable_shape)\\r\\n self_linker_time = sum([ps.linker_time for ps\\r\\n in self.profile_stats.values()])\\r\\n other_linker_time = sum([ps.linker_time for ps\\r\\n in other.profile_stats.values()])\\r\\n self_optimizer_time = sum([ps.optimizer_time for ps\\r\\n in self.profile_stats.values()])\\r\\n other_optimizer_time = sum([ps.optimizer_time for ps\\r\\n in other.profile_stats.values()])\\r\\n\\r\\n other_time = {'linker_time': self_linker_time - other_linker_time,\\r\\n 'optimizer_time': self_optimizer_time -\\r\\n other_optimizer_time}\\r\\n self.print_summary_(\\\"print_diff_summary\\\", compile_time,\\r\\n fct_call_time, fct_call,\\r\\n apply_time, apply_cimpl, message, variable_shape,\\r\\n print_apply=False, other_time=other_time,\\r\\n **kwargs)\",\n \"def postIdealizedAnalysis(inpath, outpath, member,\\n refpath='/lustre/research/bancell/aucolema/HWT2016runs/2016050800/wrfoutREF'):\\n # SENSvals file naming conventions\\n sensval_varstrings = [\\\"GPH_300\\\", \\\"GPH_500\\\", \\\"GPH_700\\\", \\\"GPH_850\\\", \\\"SKIP\\\",\\n \\\"T_300\\\", \\\"T_500\\\", \\\"T_700\\\", \\\"T_850\\\", \\\"T_925\\\",\\n \\\"U_300\\\", \\\"U_500\\\", \\\"U_700\\\", \\\"U_850\\\", \\\"U_925\\\",\\n \\\"V_300\\\", \\\"V_500\\\", \\\"V_700\\\", \\\"V_850\\\", \\\"V_925\\\",\\n \\\"SKIP\\\", \\\"SKIP\\\", \\\"SKIP\\\", \\\"SKIP\\\", \\\"SKIP\\\", \\\"SKIP\\\",\\n \\\"SKIP\\\", \\\"SKIP\\\", \\\"Q_850\\\", \\\"SKIP\\\", \\\"SLP\\\", \\\"T2\\\",\\n \\\"TD2\\\", \\\"U10\\\", \\\"V10\\\"]\\n # Post-processed new file naming conventions\\n sensstringslist = [\\\"300 hPa GPH\\\",\\\"500 hPa GPH\\\",\\\"700 hPa GPH\\\",\\n \\\"850 hPa GPH\\\",\\\"925 hPa GPH\\\",\\\"300 hPa T\\\",\\\"500 hPa T\\\",\\n \\\"700 hPa T\\\",\\\"850 hPa T\\\",\\\"925 hPa T\\\",\\\"300 hPa U-Wind\\\",\\n \\\"500 hPa U-Wind\\\",\\\"700 hPa U-Wind\\\",\\\"850 hPa U-Wind\\\",\\n \\\"925 hPa U-Wind\\\",\\\"300 hPa V-Wind\\\",\\\"500 hPa V-Wind\\\",\\n \\\"700 hPa V-Wind\\\",\\\"850 hPa V-Wind\\\",\\\"925 hPa V-Wind\\\",\\n \\\"300 hPa Dewpt\\\", \\\"500 hPa Dewpt\\\", \\\"700 hPa Dewpt\\\",\\n \\\"850 hPa Dewpt\\\", \\\"925 hPa Dewpt\\\", \\\"300 hPa Q\\\",\\n \\\"500 hPa Q\\\", \\\"700 hPa Q\\\", \\\"850 hPa Q\\\", \\\"925 hPa Q\\\",\\n \\\"SLP\\\",\\\"2m Temp\\\",\\\"2m Dewpt\\\",\\n \\\"10m U-Wind\\\",\\\"10m V-Wind\\\"]\\n\\n # Get more dimensions/geographical info\\n wrf_d1 = Dataset(refpath)\\n lons, lats = wrf_d1.variables['XLONG'][0], wrf_d1.variables['XLAT'][0]\\n wrf_idim = len(lons[0,:])\\n wrf_jdim = len(lats[:,0])\\n\\n # Write interpolated variables to netCDF\\n new_analysis = Dataset(outpath, \\\"w\\\", format=\\\"NETCDF4\\\")\\n new_analysis.createDimension('lat', wrf_jdim)\\n new_analysis.createDimension('lon', wrf_idim)\\n new_analysis.createDimension('time', None)\\n xlat = new_analysis.createVariable(\\\"XLAT\\\", float, dimensions=('lat','lon'))\\n xlat[:,:] = lats\\n xlon = new_analysis.createVariable(\\\"XLONG\\\", float, dimensions=('lat','lon'))\\n xlon[:,:] = lons\\n\\n # Open dataset and start pulling member fields\\n member_fields = np.zeros((len(sensval_varstrings), wrf_jdim, wrf_idim))\\n sensvar_dat = Dataset(inpath)\\n for ind, var in enumerate(sensval_varstrings):\\n # print(\\\"SENSvals variable:\\\", var, \\\"New variable string\\\", sensstringslist[ind])\\n if var != \\\"SKIP\\\":\\n member_fields[ind] = sensvar_dat[var][member-1][:]\\n newvar = new_analysis.createVariable(\\n sensstringslist[ind].replace(\\\" \\\",\\\"_\\\"),\\n member_fields[ind].dtype,\\n dimensions=('lat','lon'))\\n newvar[:,:] = member_fields[ind]\\n new_analysis.close()\\n return\",\n \"def postIdealizedAnalysis(inpath, outpath, member,\\n refpath='/lustre/research/bancell/aucolema/HWT2016runs/2016050800/wrfoutREF'):\\n # SENSvals file naming conventions\\n sensval_varstrings = [\\\"GPH_300\\\", \\\"GPH_500\\\", \\\"GPH_700\\\", \\\"GPH_850\\\", \\\"SKIP\\\",\\n \\\"T_300\\\", \\\"T_500\\\", \\\"T_700\\\", \\\"T_850\\\", \\\"T_925\\\",\\n \\\"U_300\\\", \\\"U_500\\\", \\\"U_700\\\", \\\"U_850\\\", \\\"U_925\\\",\\n \\\"V_300\\\", \\\"V_500\\\", \\\"V_700\\\", \\\"V_850\\\", \\\"V_925\\\",\\n \\\"SKIP\\\", \\\"SKIP\\\", \\\"SKIP\\\", \\\"SKIP\\\", \\\"SKIP\\\", \\\"SKIP\\\",\\n \\\"SKIP\\\", \\\"SKIP\\\", \\\"Q_850\\\", \\\"SKIP\\\", \\\"SLP\\\", \\\"T2\\\",\\n \\\"TD2\\\", \\\"U10\\\", \\\"V10\\\"]\\n # Post-processed new file naming conventions\\n sensstringslist = [\\\"300 hPa GPH\\\",\\\"500 hPa GPH\\\",\\\"700 hPa GPH\\\",\\n \\\"850 hPa GPH\\\",\\\"925 hPa GPH\\\",\\\"300 hPa T\\\",\\\"500 hPa T\\\",\\n \\\"700 hPa T\\\",\\\"850 hPa T\\\",\\\"925 hPa T\\\",\\\"300 hPa U-Wind\\\",\\n \\\"500 hPa U-Wind\\\",\\\"700 hPa U-Wind\\\",\\\"850 hPa U-Wind\\\",\\n \\\"925 hPa U-Wind\\\",\\\"300 hPa V-Wind\\\",\\\"500 hPa V-Wind\\\",\\n \\\"700 hPa V-Wind\\\",\\\"850 hPa V-Wind\\\",\\\"925 hPa V-Wind\\\",\\n \\\"300 hPa Dewpt\\\", \\\"500 hPa Dewpt\\\", \\\"700 hPa Dewpt\\\",\\n \\\"850 hPa Dewpt\\\", \\\"925 hPa Dewpt\\\", \\\"300 hPa Q\\\",\\n \\\"500 hPa Q\\\", \\\"700 hPa Q\\\", \\\"850 hPa Q\\\", \\\"925 hPa Q\\\",\\n \\\"SLP\\\",\\\"2m Temp\\\",\\\"2m Dewpt\\\",\\n \\\"10m U-Wind\\\",\\\"10m V-Wind\\\"]\\n\\n # Get more dimensions/geographical info\\n wrf_d1 = Dataset(refpath)\\n lons, lats = wrf_d1.variables['XLONG'][0], wrf_d1.variables['XLAT'][0]\\n wrf_idim = len(lons[0,:])\\n wrf_jdim = len(lats[:,0])\\n\\n # Write interpolated variables to netCDF\\n new_analysis = Dataset(outpath, \\\"w\\\", format=\\\"NETCDF4\\\")\\n new_analysis.createDimension('lat', wrf_jdim)\\n new_analysis.createDimension('lon', wrf_idim)\\n new_analysis.createDimension('time', None)\\n xlat = new_analysis.createVariable(\\\"XLAT\\\", float, dimensions=('lat','lon'))\\n xlat[:,:] = lats\\n xlon = new_analysis.createVariable(\\\"XLONG\\\", float, dimensions=('lat','lon'))\\n xlon[:,:] = lons\\n\\n # Open dataset and start pulling member fields\\n member_fields = np.zeros((len(sensval_varstrings), wrf_jdim, wrf_idim))\\n sensvar_dat = Dataset(inpath)\\n for ind, var in enumerate(sensval_varstrings):\\n # print(\\\"SENSvals variable:\\\", var, \\\"New variable string\\\", sensstringslist[ind])\\n if var != \\\"SKIP\\\":\\n member_fields[ind] = sensvar_dat[var][member-1][:]\\n newvar = new_analysis.createVariable(\\n sensstringslist[ind].replace(\\\" \\\",\\\"_\\\"),\\n member_fields[ind].dtype,\\n dimensions=('lat','lon'))\\n newvar[:,:] = member_fields[ind]\\n new_analysis.close()\\n return\",\n \"def _pop_path(diffs):\\n key = None\\n popped_diffs = []\\n for d in diffs:\\n # Empty diffs can be skipped\\n if d is None or len(d) == 0:\\n popped_diffs.append(None)\\n continue\\n # Check that we have only one op, which is a patch op\\n if len(d) != 1 or d[0].op != DiffOp.PATCH:\\n return\\n # Ensure all present diffs have the same key\\n if key is None:\\n key = d[0].key\\n elif key != d[0].key:\\n return\\n # Ensure the sub diffs of all ops are suitable as outer layer\\n # if d[0].diff.length > 1:\\n # return\\n popped_diffs.append(d[0].diff)\\n if key is None:\\n return\\n return {'key': key, 'diffs': popped_diffs}\",\n \"def analyze(errors_log_fp: str, visualization_fp: str):\\n # Read lines from errors log\\n with open(errors_log_fp, 'r', encoding='utf-8') as f:\\n lines = f.readlines()\\n\\n # Process lines\\n tn_error_cases, itn_error_cases = [], []\\n for ix in range(0, len(lines), 8):\\n mode_line = lines[ix]\\n info_lines = lines[ix + 1 : ix + 7]\\n # Append new error case\\n if mode_line.startswith('Forward Problem'):\\n mode = constants.TN_MODE\\n tn_error_cases.append(ErrorCase.from_lines(info_lines, mode))\\n elif mode_line.startswith('Backward Problem'):\\n mode = constants.ITN_MODE\\n itn_error_cases.append(ErrorCase.from_lines(info_lines, mode))\\n\\n # Basic stats\\n print('---- Text Normalization ----')\\n print('Number of TN errors: {}'.format(len(tn_error_cases)))\\n\\n print('---- Inverse Text Normalization ---- ')\\n print('Number of ITN errors: {}'.format(len(itn_error_cases)))\\n\\n # Produce a visualization\\n with open(visualization_fp, 'w+', encoding='utf-8') as f:\\n # Appendix\\n f.write('Appendix</br>')\\n f.write('<a href=\\\"#tn_section\\\">Text Normalization Analysis.</a></br>')\\n f.write('<a href=\\\"#itn_section\\\">Inverse Text Normalization Analysis.</a>')\\n\\n # TN Section\\n f.write('<h2 id=\\\"tn_section\\\">Text Normalization</h2>\\\\n')\\n for errorcase in tn_error_cases:\\n f.write(errorcase.get_html())\\n\\n # ITN Section\\n f.write('<h2 id=\\\"itn_section\\\">Inverse Text Normalization</h2>\\\\n')\\n for errorcase in itn_error_cases:\\n f.write(errorcase.get_html())\",\n \"def getStiff(self, calc, **kwargs):\\n elements = [e for e in self.elements if e.dim == 2]\\n ns = len(self.nodes)\\n self.stiff = zeros((ns, ns))\\n for e in elements:\\n calc(e)\\n indexes = [(n1.i - 1, n2.i-1) for n1 in e.nodes for n2 in e.nodes]\\n for i, p in enumerate(indexes):\\n x, y = p\\n self.stiff[x, y] += e.M.flat[i]\\n return self.stiff\",\n \"def compareAB(model1_name, model2_name, X_test_B, X_test_S, analysis_dir=\\\"Analysis/\\\"):\\n #Load best weights\\n model = tf.keras.models.load_model(\\\"Models/\\\"+model1_name)\\n bkg_preds1 = model.predict(X_test_B).flatten()\\n sig_preds1 = model.predict(X_test_S).flatten()\\n\\n model = tf.keras.models.load_model(\\\"Models/\\\"+model2_name)\\n bkg_preds2 = model.predict(X_test_B).flatten()\\n sig_preds2 = model.predict(X_test_S).flatten()\\n\\n sig_eff = []\\n bkg_eff = []\\n sig_eff_50 = 1.0\\n bkg_eff_50 = 1.0\\n for thresh in (1-np.arange(0.00005, 0.8, 0.01)):\\n bkg_eff_temp = np.sum(bkg_preds1 > thresh)/len(bkg_preds1)\\n sig_eff_temp = np.sum(sig_preds1 > thresh)/len(sig_preds1)\\n sig_eff.append(sig_eff_temp)\\n bkg_eff.append(1/bkg_eff_temp)\\n if abs(sig_eff_temp-0.5) < abs(sig_eff_50-0.5):\\n sig_eff_50 = sig_eff_temp\\n bkg_eff_50 = 1/bkg_eff_temp\\n plt.semilogy(sig_eff, bkg_eff)\\n plt.annotate(model1_name + ' Background rejection @0.5 Signal efficiency = {:.2e}'.format(bkg_eff_50), xy=(0.05, 0.95), xycoords='axes fraction')\\n print(sig_eff_50)\\n\\n sig_eff = []\\n bkg_eff = []\\n sig_eff_50 = 1.0\\n bkg_eff_50 = 1.0\\n for thresh in (1-np.arange(0.00005, 0.8, 0.01)):\\n bkg_eff_temp = np.sum(bkg_preds2 > thresh)/len(bkg_preds2)\\n sig_eff_temp = np.sum(sig_preds2 > thresh)/len(sig_preds2)\\n sig_eff.append(sig_eff_temp)\\n bkg_eff.append(1/bkg_eff_temp)\\n if abs(sig_eff_temp-0.5) < abs(sig_eff_50-0.5):\\n sig_eff_50 = sig_eff_temp\\n bkg_eff_50 = 1/bkg_eff_temp\\n plt.semilogy(sig_eff, bkg_eff)\\n plt.annotate(model2_name + ' Background rejection @0.5 Signal efficiency = {:.3e}'.format(bkg_eff_50), xy=(0.05, 0.88), xycoords='axes fraction')\\n print(sig_eff_50)\\n\\n plt.legend([model1_name, model2_name])\\n plt.xlabel(\\\"Signal efficiency\\\")\\n plt.ylabel(\\\"Background rejection\\\")\\n plt.gcf().set_size_inches(8.3, 5.85)\\n plt.savefig(analysis_dir+\\\"ROC\\\" + model1_name + \\\"VS\\\" + model2_name + \\\".pdf\\\", format=\\\"pdf\\\")\\n plt.show()\",\n \"def preprocess(self):\\n travel_path = []\\n current_location = None\\n last_valid_location = None\\n change_at_day = None\\n location_candidate = None\\n\\n for commit in self.raw_data:\\n commit_time = commit.commit_time\\n commit_timezone = commit.commit_time_offset\\n if commit_timezone is None:\\n continue\\n\\n zones = self.session.query(TimezoneInterval.timezone) \\\\\\n .filter(TimezoneInterval.start <= commit_time) \\\\\\n .filter(TimezoneInterval.end > commit_time) \\\\\\n .filter(TimezoneInterval.utcoffset == commit_timezone) \\\\\\n .all()\\n\\n # Create the initial timezone\\n if current_location is None:\\n current_location = {\\n 'set': set([z[0] for z in zones]),\\n 'full_set': set([z[0] for z in zones]),\\n 'start': commit_time.date(),\\n 'end': commit_time.date(),\\n }\\n last_valid_location = commit_time.date()\\n\\n continue\\n\\n # We got a timezone and need to check if we are still in it or if there is a change\\n # Get possible timezone candidates for this commit and intersect them with the current_location set\\n location = set([z[0] for z in zones])\\n intersection = location & current_location['set']\\n # Check if the possible timezones of this commit matches any timezone of the current set.\\n if len(intersection) > 0:\\n # By reassigning the intersected set we gain additional precision by considering possible specific DST changes\\n current_location['set'] = intersection\\n current_location['end'] = commit_time.date()\\n last_valid_location = commit_time.date()\\n\\n # There is no match between the possible timezones and the current set.\\n # In this case we need to check if this is a single occurrence (anomaly) or\\n # If this is an actual change.\\n else:\\n # No change_at_day exists, but we detected a change\\n # Remember the change. If this change lasts for at least a day it will be marked.\\n if change_at_day is None:\\n change_at_day = commit.commit_time.date()\\n location_candidate = {\\n 'set': set([z[0] for z in zones]),\\n 'full_set': set([z[0] for z in zones]),\\n 'start': commit_time.date(),\\n 'end': commit_time.date(),\\n }\\n\\n # No change detected\\n if change_at_day is None:\\n continue\\n\\n # There was an anomaly, but not for a whole day.\\n # This could for instance be a developer committing from a remote server.\\n if change_at_day <= last_valid_location:\\n change_at_day = None\\n location_candidate = None\\n\\n continue\\n\\n # The change is not older than a day\\n # ignore it until the change lasts for longer than a day\\n if change_at_day <= last_valid_location:\\n continue\\n\\n # There exists a change from the last day.\\n duration = current_location['end'] - current_location['start']\\n\\n # The current_location set exists only for a single day.\\n # This is most likely an outlier. Thereby drop it and restore the last timezone.\\n if duration < timedelta(days=1) and len(travel_path) > 0:\\n last_location = travel_path.pop()\\n last_location['end'] = current_location['end']\\n current_location = last_location\\n\\n # Check if the old location and the current candidate actually match\\n # If that's the case drop the candidate and completely replace the current_location set\\n intersection = location_candidate['set'] & current_location['set']\\n if len(intersection) > 0:\\n # Update current_timezone\\n current_location['set'] = intersection\\n current_location['end'] = commit_time.date()\\n current_location['full_set'] = current_location['full_set'] | location_candidate['set']\\n\\n # Reset candidate and last_valid_location occurrence\\n last_valid_location = commit_time.date()\\n change_at_day = None\\n location_candidate = None\\n\\n continue\\n\\n # We detected a change and it seems to be valid.\\n # Save the current timezone and set the candidate as the current timezone.\\n travel_path.append(current_location)\\n current_location = location_candidate\\n change_at_day = None\\n location_candidate = None\\n last_valid_location = commit_time.date()\\n\\n current_location['end'] = datetime.now().date()\\n travel_path.append(current_location)\\n\\n home_location_candidates = []\\n home_location = None\\n found = False\\n # Try to find the current home timezone:\\n for location in travel_path:\\n duration = location['end'] - location['start']\\n\\n # Try to find a set which intersects with the current set\\n for candidate in home_location_candidates:\\n intersection = location['set'] & candidate['set']\\n # Found an intersection, set the new intersection and increment days\\n if len(intersection) > 0:\\n candidate['set'] = intersection\\n candidate['days'] += duration.days\\n candidate['full_set'] = location['full_set'] | candidate['full_set']\\n found = True\\n if candidate['days'] > home_location['days']:\\n home_location = candidate\\n\\n break\\n\\n if not found:\\n location['days'] = duration.days\\n home_location_candidates.append(location)\\n else:\\n found = False\\n\\n if not home_location:\\n home_location = location\\n\\n self.data = travel_path\\n self.home_zone = home_location\\n self.different_timezones = len(home_location_candidates)\",\n \"def print_diff_summary(self, other, **kwargs):\\n\\n def diff_dict(a_time, b_time_):\\n r = {}\\n b_time = copy.copy(b_time_)\\n for a, ta in iteritems(a_time):\\n r.setdefault(a, 0)\\n tb = b_time.pop(a, 0)\\n r[a] += ta - tb\\n\\n # they are missing in a\\n for a, t in iteritems(b_time):\\n r.setdefault(a, 0)\\n r[a] += t\\n return r\\n\\n compile_time = self.compile_time - other.compile_time\\n fct_call_time = diff_dict(self.fct_call_time, other.fct_call_time)\\n fct_call = diff_dict(self.fct_call, other.fct_call)\\n apply_time = diff_dict(self.apply_time, other.apply_time)\\n apply_cimpl = self.apply_cimpl and other.apply_cimpl\\n message = self.message\\n variable_shape = diff_dict(self.variable_shape, other.variable_shape)\\n self_linker_time = sum([ps.linker_time for ps\\n in self.profile_stats.values()])\\n other_linker_time = sum([ps.linker_time for ps\\n in other.profile_stats.values()])\\n self_optimizer_time = sum([ps.optimizer_time for ps\\n in self.profile_stats.values()])\\n other_optimizer_time = sum([ps.optimizer_time for ps\\n in other.profile_stats.values()])\\n\\n other_time = {'linker_time': self_linker_time - other_linker_time,\\n 'optimizer_time': self_optimizer_time -\\n other_optimizer_time}\\n self.print_summary_(\\\"print_diff_summary\\\", compile_time,\\n fct_call_time, fct_call,\\n apply_time, apply_cimpl, message, variable_shape,\\n print_apply=False, other_time=other_time,\\n **kwargs)\",\n \"def _get_draft_details(request, comments):\\n last_key = None\\n output = []\\n linecache = {} # Maps (c.patch_key, c.left) to mapping (lineno, line)\\n modified_patches = []\\n fetch_base_failed = False\\n\\n for c in comments:\\n patch = c.patch_key.get()\\n if (patch.key, c.left) != last_key:\\n url = request.build_absolute_uri(\\n reverse(diff, args=[request.issue.key.id(),\\n patch.patchset_key.id(),\\n patch.filename]))\\n output.append('\\\\n%s\\\\nFile %s (%s):' % (url, patch.filename,\\n c.left and \\\"left\\\" or \\\"right\\\"))\\n last_key = (patch.key, c.left)\\n if patch.no_base_file:\\n linecache[last_key] = _patchlines2cache(\\n patching.ParsePatchToLines(patch.lines), c.left)\\n else:\\n try:\\n if c.left:\\n old_lines = patch.get_content().text.splitlines(True)\\n linecache[last_key] = dict(enumerate(old_lines, 1))\\n else:\\n new_lines = patch.get_patched_content().text.splitlines(True)\\n linecache[last_key] = dict(enumerate(new_lines, 1))\\n except FetchError:\\n linecache[last_key] = _patchlines2cache(\\n patching.ParsePatchToLines(patch.lines), c.left)\\n fetch_base_failed = True\\n context = linecache[last_key].get(c.lineno, '').strip()\\n url = request.build_absolute_uri(\\n '%s#%scode%d' % (reverse(diff, args=[request.issue.key.id(),\\n patch.patchset_key.id(),\\n patch.filename]),\\n c.left and \\\"old\\\" or \\\"new\\\",\\n c.lineno))\\n output.append('\\\\n%s\\\\n%s:%d: %s\\\\n%s' % (url, patch.filename, c.lineno,\\n context, c.text.rstrip()))\\n if modified_patches:\\n ndb.put_multi(modified_patches)\\n return '\\\\n'.join(output)\",\n \"def __do_analysis(self):\\n #Step 1: connect to mongodb and pick a streamer\\n dbclient = db_connect.DBClient()\\n streamer_data = dbclient.analyze_number_of_stream_viewers(self.streamer)\\n streamer_messeges_data = dbclient.analyzeStream(self.streamer)\\n\\n timearr = []\\n messagesarr = []\\n streamer_timearr = []\\n num_chattersarr = []\\n\\n #create time and messages array for plotting purposes\\n for entry in streamer_messeges_data:\\n timearr.append(entry['start_time'])\\n messagesarr.append(entry['messeges_count'] * entry['messeges_count'])\\n #print(entry['start_time'])\\n\\n #create time and chatters array for plotting purposes\\n for entry in streamer_data:\\n streamer_timearr.append(entry['deltatime_from_start_of_clip'])\\n num_chattersarr.append(entry['num_viewers'])\\n\\n # print('start time: ' + str(timearr[0]))\\n # print('end time: ' + str(timearr[-1]))\\n # print('duration: ' + str(timearr[-1] - timearr[0]))\\n # print('average views/min = ' + str(sum(messagesarr) / len(messagesarr)))\\n\\n average_message_count = sum(messagesarr) / len(messagesarr)\\n\\n averagearr = []\\n plotting_time_arr = []\\n labelarr = []\\n\\n for i in range(len(timearr)):\\n averagearr.append(average_message_count*1.8)\\n #print(str(timearr[i]) + ' converts to ' + str(datetime.datetime(2020, 1, 1, 0, 0) + timearr[i]))\\n plotting_time_arr.append(datetime.datetime(2020, 1, 1, 0, 0) + timearr[i])\\n labelarr.append(str(i))\\n\\n plotting_streamer_timearr = []\\n for i in range(len(streamer_timearr)):\\n plotting_streamer_timearr.append(datetime.datetime(2020, 1, 1, 0, 0) + streamer_timearr[i])\\n\\n #plot messages and cuttoff\\n messeges_over_time_fig = pyplot.figure(1)\\n messeges_over_time_fig.set_figheight(15)\\n messeges_over_time_fig.set_figwidth(30)\\n messeges_over_time_fig.suptitle(self.streamer + \\\"'s video data\\\")\\n messeges_over_time_sub = messeges_over_time_fig.add_subplot(211)\\n\\n pyplot.plot(plotting_time_arr,messagesarr,label='messages/min')\\n dots = pyplot.plot(plotting_time_arr,messagesarr,'bo',label='messages/min')\\n\\n #label dots\\n count = 0\\n last_entry_was_above_line = False\\n for i in range(len(plotting_time_arr)):\\n #print(str(count) +': comparing ' + str(messagesarr[i]) + ' with ' + str(averagearr[i]))\\n if(messagesarr[i] > averagearr[i]):\\n if(last_entry_was_above_line):\\n #Don't increment the count because this is part of the same clip\\n count = count\\n else:\\n #new clip above the line, increment clip count\\n count = count + 1\\n messeges_over_time_sub.annotate(count,xy=(plotting_time_arr[i],messagesarr[i]))\\n last_entry_was_above_line = True\\n else:\\n last_entry_was_above_line = False\\n # messeges_over_time_sub.annotate('NA',xy=(plotting_time_arr[i],messagesarr[i]))\\n\\n #finish plotting\\n pyplot.plot(plotting_time_arr, averagearr,'',label='average')\\n pyplot.gcf().autofmt_xdate()\\n pyplot.ylabel('Messeges*Messeges')\\n pyplot.xlabel('Time')\\n\\n viewers_over_time_sub = messeges_over_time_fig.add_subplot(212)\\n\\n pyplot.plot(plotting_streamer_timearr,num_chattersarr,label='num chatters')\\n pyplot.ylabel('Chatters')\\n pyplot.xlabel('Time')\\n\\n pyplot.tight_layout()\\n pyplot.savefig(output_file_location+self.streamer+'.png')\\n print('saved chart to ' + output_file_location+self.streamer+'.png')\\n # pyplot.show()\\n return average_message_count, streamer_messeges_data\",\n \"def legitimate_mark_changes(self, verbose=False):\\n if self._undirected:\\n raise ValueError('Only defined for DMAGs')\\n\\n disc_paths = self.discriminating_paths()\\n\\n mark_changes_dir = set()\\n for i, j in self._directed:\\n if verbose: print(f'{i}->{j} => {i}<->{j} ?')\\n # FIRST CONDITIONS\\n parents_condition = all(self.has_directed(parent, j) for parent in self._parents[i])\\n if not parents_condition:\\n if verbose: print('Failed parents condition')\\n continue\\n spouses_condition = all(self.has_any_edge(spouse, j) for spouse in self._spouses[i])\\n if not spouses_condition:\\n if verbose: print('Failed spouses condition')\\n continue\\n\\n # SECOND CONDITION\\n disc_paths_for_i = [path for path in disc_paths.keys() if path[-2] == i]\\n disc_paths_condition = all(path[-1] != j for path in disc_paths_for_i)\\n if not disc_paths_condition:\\n if verbose: print('Failed discriminating path condition')\\n continue\\n\\n # FINAL CONDITION\\n if i in self.ancestors_of(j, exclude_arcs={(i, j)}):\\n if verbose: print('Failed ancestral condition')\\n continue\\n\\n if verbose: print('Passed')\\n mark_changes_dir.add((i, j))\\n\\n mark_changes_bidir = set()\\n for i, j in self._bidirected | set(map(reversed, self._bidirected)):\\n if verbose: print(f'{i}<->{j} => {i}->{j} ?')\\n # FIRST CONDITIONS\\n parents_condition = all(self.has_directed(parent, j) for parent in self._parents[i])\\n if not parents_condition:\\n if verbose: print('Failed parents condition')\\n continue\\n spouses_condition = all(self.has_any_edge(spouse, j) for spouse in self._spouses[i] if spouse != j)\\n if not spouses_condition:\\n if verbose: print('Failed spouses condition')\\n continue\\n\\n # SECOND CONDITION\\n disc_paths_for_i = [path for path in disc_paths.keys() if path[-2] == i]\\n disc_paths_condition = all(path[-1] != j for path in disc_paths_for_i)\\n if not disc_paths_condition:\\n if verbose: print('Failed discriminating path condition')\\n continue\\n\\n # FINAL CONDITION\\n if i in self.ancestors_of(j):\\n if verbose: print('Failed ancestral condition')\\n continue\\n\\n if verbose: print('Passed')\\n mark_changes_bidir.add((i, j))\\n\\n return mark_changes_dir, mark_changes_bidir\",\n \"def deal_lines(self, lines, conf):\\n if lines == ['']:\\n print \\\"NO new %s commit!\\\" % conf\\n else:\\n for line in lines:\\n if re.search('\\\\d+ files? changed', line) is None:\\n pos = line.find(' ')\\n if pos != -1:\\n try:\\n parts = line.split(' ', 2)\\n commit_id = parts[0]\\n self.current_commit = commit_id\\n stamp = int(parts[1])\\n ti = datetime.datetime.fromtimestamp(float(stamp))\\n s_time = datetime.datetime.fromtimestamp(float(0))\\n if self.start_date == s_time:\\n self.start_date = ti\\n elif self.start_date > ti:\\n self.start_date = ti\\n author, mail = parts[2].split('<', 1)\\n message = mail.split('> ', 1)[1]\\n mail = mail.split('>', 1)[0]\\n if re.search(': ', message) is not None:\\n messagetype = message.split(': ', 1)[0]\\n if messagetype not in CLASSIFICATION:\\n messagetype = 'OTR'\\n else:\\n messagetype = 'OTR'\\n if commit_id not in self.commit_dictionary:\\n self.commit_dictionary[commit_id]\\\\\\n = [commit_id, mail,\\n stamp, messagetype,\\n messagetype, 0, 0, 0, 0]\\n # [files, inserted, deleted, total_lines]\\n if mail not in self.author_dictionary:\\n self.author_dictionary[mail] = [author,\\n mail, 0, 0,\\n 0, 0, 1,\\n stamp]\\n # [files,inserted,deleted,total_lines,commit,stamp]\\n else:\\n self.author_dictionary[mail][6] += 1\\n if stamp > self.author_dictionary[mail][7]:\\n self.author_dictionary[mail][7] = stamp\\n self.total_patches += 1\\n except:\\n print 'Warning: unexpected line \\\"%s\\\"' % line\\n else:\\n if conf == 'no_merges':\\n try:\\n commit_id = self.current_commit\\n numbers = self.getstatsummarycounts(line)\\n if len(numbers) == 3:\\n (files, inserted, deleted) = \\\\\\n map(lambda el: int(el), numbers)\\n total_lines = inserted - deleted\\n self.commit_dictionary[commit_id][5] = files\\n self.commit_dictionary[commit_id][6] = inserted\\n self.commit_dictionary[commit_id][7] = deleted\\n self.commit_dictionary[commit_id][8] = total_lines\\n self.author_dictionary[mail][2] += files\\n self.author_dictionary[mail][3] += inserted\\n self.author_dictionary[mail][4] += deleted\\n self.author_dictionary[mail][5] += total_lines\\n self.total_lines_inserted += inserted\\n self.total_lines_deleted += deleted\\n self.total_lines += total_lines\\n self.current_commit = None\\n except:\\n print 'Warning: unexpected line \\\"%s\\\"' % line\",\n \"def _transition_from_PREPARING(self, run_state):\\n\\n def mount_dependency(dependency, shared_file_system):\\n if not shared_file_system:\\n # Set up symlinks for the content at dependency path\\n Path(dependency.child_path).parent.mkdir(parents=True, exist_ok=True)\\n os.symlink(dependency.docker_path, dependency.child_path)\\n # The following will be converted into a Docker volume binding like:\\n # dependency_path:docker_dependency_path:ro\\n docker_dependencies.append((dependency.parent_path, dependency.docker_path))\\n\\n if run_state.is_killed or run_state.is_restaged:\\n log_bundle_transition(\\n bundle_uuid=run_state.bundle.uuid,\\n previous_stage=run_state.stage,\\n next_stage=RunStage.CLEANING_UP,\\n reason=f'the bundle was {\\\"killed\\\" if run_state.is_killed else \\\"restaged\\\"}',\\n )\\n return run_state._replace(stage=RunStage.CLEANING_UP)\\n\\n # Check CPU and GPU availability\\n try:\\n cpuset, gpuset = self.assign_cpu_and_gpu_sets_fn(\\n run_state.resources.cpus, run_state.resources.gpus\\n )\\n except Exception as e:\\n message = \\\"Unexpectedly unable to assign enough resources to bundle {}: {}\\\".format(\\n run_state.bundle.uuid, str(e)\\n )\\n logger.error(message)\\n logger.error(traceback.format_exc())\\n return run_state._replace(run_status=message)\\n\\n dependencies_ready = True\\n status_messages = []\\n dependency_keys_to_paths: Dict[DependencyKey, str] = dict()\\n\\n if not self.shared_file_system:\\n # No need to download dependencies if we're in the shared FS,\\n # since they're already in our FS\\n for dep in run_state.bundle.dependencies:\\n dep_key = DependencyKey(dep.parent_uuid, dep.parent_path)\\n\\n try:\\n # Fetching dependencies from the Dependency Manager can fail.\\n # Just update the download status on the next iteration of this transition function.\\n dependency_state = self.dependency_manager.get(run_state.bundle.uuid, dep_key)\\n dependency_keys_to_paths[dep_key] = os.path.join(\\n self.dependency_manager.dependencies_dir, dependency_state.path\\n )\\n except Exception:\\n status_messages.append(f'Downloading dependency {dep.child_path} failed')\\n dependencies_ready = False\\n continue\\n\\n if dependency_state.stage == DependencyStage.DOWNLOADING:\\n status_messages.append(\\n 'Downloading dependency %s: %s done (archived size)'\\n % (dep.child_path, size_str(dependency_state.size_bytes))\\n )\\n dependencies_ready = False\\n elif dependency_state.stage == DependencyStage.FAILED:\\n # Failed to download dependency; -> CLEANING_UP\\n log_bundle_transition(\\n bundle_uuid=run_state.bundle.uuid,\\n previous_stage=run_state.stage,\\n next_stage=RunStage.CLEANING_UP,\\n reason=f'Dependency has failed for this bundle. Dependency child uuid: {dep.child_uuid}. Dependency child path: {dep.child_path}',\\n )\\n return run_state._replace(\\n stage=RunStage.CLEANING_UP,\\n failure_message='Failed to download dependency %s: %s'\\n % (dep.child_path, dependency_state.message),\\n )\\n\\n # get the docker image\\n docker_image = run_state.resources.docker_image\\n image_state = self.image_manager.get(docker_image)\\n if image_state.stage == DependencyStage.DOWNLOADING:\\n status_messages.append(\\n 'Pulling docker image %s. %s' % (docker_image, image_state.message)\\n )\\n dependencies_ready = False\\n elif image_state.stage == DependencyStage.FAILED:\\n # Failed to pull image; -> CLEANING_UP\\n message = 'Failed to download Docker image: %s' % image_state.message\\n logger.error(message)\\n return run_state._replace(stage=RunStage.CLEANING_UP, failure_message=message)\\n\\n # stop proceeding if dependency and image downloads aren't all done\\n if not dependencies_ready:\\n status_message = status_messages.pop()\\n if status_messages:\\n status_message += \\\"(and downloading %d other dependencies and docker images)\\\" % len(\\n status_messages\\n )\\n logger.info(\\n f'bundle is not ready yet. uuid: {run_state.bundle.uuid}. status message: {status_message}'\\n )\\n return run_state._replace(run_status=status_message)\\n\\n # All dependencies ready! Set up directories, symlinks and container. Start container.\\n # 1) Set up a directory to store the bundle.\\n if self.shared_file_system:\\n if not os.path.exists(run_state.bundle_path):\\n if run_state.bundle_dir_wait_num_tries == 0:\\n message = (\\n \\\"Bundle directory cannot be found on the shared filesystem. \\\"\\n \\\"Please ensure the shared filesystem between the server and \\\"\\n \\\"your worker is mounted properly or contact your administrators.\\\"\\n )\\n log_bundle_transition(\\n bundle_uuid=run_state.bundle.uuid,\\n previous_stage=run_state.stage,\\n next_stage=RunStage.CLEANING_UP,\\n reason=\\\"Bundle directory cannot be found on the shared filesystem.\\\",\\n )\\n return run_state._replace(stage=RunStage.CLEANING_UP, failure_message=message)\\n next_bundle_dir_wait_num_tries = run_state.bundle_dir_wait_num_tries - 1\\n logger.info(\\n f'Waiting for bundle directory to be created by the server, uuid: {run_state.bundle.uuid}, bundle_dir_wait_num_tries: {next_bundle_dir_wait_num_tries}'\\n )\\n return run_state._replace(\\n run_status=\\\"Waiting for bundle directory to be created by the server\\\",\\n bundle_dir_wait_num_tries=next_bundle_dir_wait_num_tries,\\n )\\n else:\\n os.makedirs(run_state.bundle_path, exist_ok=True)\\n\\n # 2) Set up symlinks\\n docker_dependencies = []\\n docker_dependencies_path = (\\n RunStateMachine._ROOT\\n + run_state.bundle.uuid\\n + ('_dependencies' if not self.shared_file_system else '')\\n )\\n\\n for dep in run_state.bundle.dependencies:\\n full_child_path = os.path.normpath(os.path.join(run_state.bundle_path, dep.child_path))\\n to_mount = []\\n if self.shared_file_system:\\n # TODO(Ashwin): make this not fs-specific.\\n # On a shared FS, we know where the dependency is stored and can get the contents directly\\n dependency_path = os.path.realpath(os.path.join(dep.location, dep.parent_path))\\n else:\\n dep_key = DependencyKey(dep.parent_uuid, dep.parent_path)\\n dependency_path = dependency_keys_to_paths[dep_key]\\n\\n if dep.child_path == RunStateMachine._CURRENT_DIRECTORY:\\n # Mount all the content of the dependency_path to the top-level of the bundle\\n for child in os.listdir(dependency_path):\\n child_path = os.path.normpath(os.path.join(run_state.bundle_path, child))\\n to_mount.append(\\n DependencyToMount(\\n docker_path=os.path.join(docker_dependencies_path, child),\\n child_path=child_path,\\n parent_path=os.path.join(dependency_path, child),\\n )\\n )\\n run_state = run_state._replace(\\n paths_to_remove=(run_state.paths_to_remove or []) + [child_path]\\n )\\n else:\\n to_mount.append(\\n DependencyToMount(\\n docker_path=os.path.join(docker_dependencies_path, dep.child_path),\\n child_path=full_child_path,\\n parent_path=dependency_path,\\n )\\n )\\n\\n first_element_of_path = Path(dep.child_path).parts[0]\\n if first_element_of_path == RunStateMachine._ROOT:\\n run_state = run_state._replace(\\n paths_to_remove=(run_state.paths_to_remove or []) + [full_child_path]\\n )\\n else:\\n # child_path can be a nested path, so later remove everything from the first element of the path\\n path_to_remove = os.path.join(run_state.bundle_path, first_element_of_path)\\n run_state = run_state._replace(\\n paths_to_remove=(run_state.paths_to_remove or []) + [path_to_remove]\\n )\\n for dependency in to_mount:\\n try:\\n mount_dependency(dependency, self.shared_file_system)\\n except OSError as e:\\n log_bundle_transition(\\n bundle_uuid=run_state.bundle.uuid,\\n previous_stage=run_state.stage,\\n next_stage=RunStage.CLEANING_UP,\\n reason=str(e.__class__),\\n level=logging.ERROR,\\n )\\n return run_state._replace(stage=RunStage.CLEANING_UP, failure_message=str(e))\\n\\n if run_state.resources.network:\\n docker_network = self.docker_network_external.name\\n else:\\n docker_network = self.docker_network_internal.name\\n\\n # 3) Start container\\n try:\\n container_id = self.bundle_runtime.start_bundle_container(\\n run_state.bundle_path,\\n run_state.bundle.uuid,\\n docker_dependencies,\\n run_state.bundle.command,\\n run_state.resources.docker_image,\\n network=docker_network,\\n cpuset=cpuset,\\n gpuset=gpuset,\\n request_cpus=run_state.resources.cpus,\\n request_gpus=run_state.resources.gpus,\\n memory_bytes=run_state.resources.memory,\\n runtime=self.docker_runtime,\\n shared_memory_size_gb=self.shared_memory_size_gb,\\n )\\n self.worker_docker_network.connect(container_id)\\n except DockerUserErrorException as e:\\n message = 'Cannot start Docker container: {}'.format(e)\\n log_bundle_transition(\\n bundle_uuid=run_state.bundle.uuid,\\n previous_stage=run_state.stage,\\n next_stage=RunStage.CLEANING_UP,\\n reason='Cannot start Docker container.',\\n level=logging.ERROR,\\n )\\n return run_state._replace(stage=RunStage.CLEANING_UP, failure_message=message)\\n except Exception as e:\\n message = 'Cannot start container: {}'.format(e)\\n logger.error(message)\\n logger.error(traceback.format_exc())\\n raise\\n\\n return run_state._replace(\\n stage=RunStage.RUNNING,\\n run_status='Running job in container.',\\n container_id=container_id,\\n container=None,\\n docker_image=image_state.digest,\\n has_contents=True,\\n cpuset=cpuset,\\n gpuset=gpuset,\\n )\",\n \"def extract(self, extract_from, extract_to):\\n # Some API calls do not expect a TZ, so we have to remove the timezone\\n # from the dates. We assume that all dates coming from upstream are\\n # in UTC TZ.\\n extract_from = extract_from.replace(tzinfo=None)\\n extract_to = extract_to.replace(tzinfo=None)\\n\\n # Our records\\n self.records = {}\\n self.acc_records = {}\\n\\n # We cannot use just 'changes-since' in the servers.list() API query,\\n # as it will only include servers that have changed its status after\\n # that date. However we cannot just get all the usages and then query\\n # server by server, as deleted servers are not returned by the usages\\n # call. Moreover, Nova resets the start_time after performing some\\n # actions on the server (rebuild, resize, rescue). If we use that time,\\n # we may get a drop in the wall time, as a server that has been resized\\n # in the middle of its lifetime will suddenly change its start_time\\n #\\n # Therefore, what we do is the following (hackish approach)\\n #\\n # 1.- List all the servers that changed its status after the start time\\n # for the reporting period\\n # 2.- Build the records for the period [start, end] using those servers\\n # 3.- Get all the usages, being aware that the start time may be wrong\\n # 4.- Iter over the usages and:\\n # 4.1.- get information for servers that are not returned by the query\\n # in (1), for instance servers that have not changed it status.\\n # We build then the records for those severs\\n # 4.2.- For all the servers, adjust the CPU, memory and disk resources\\n # as the flavor may not exist, but we can get those resources\\n # from the usages API.\\n\\n # Lets start\\n\\n # 1.- List all the deleted servers from that period.\\n servers = self._get_servers(extract_from)\\n # 2.- Build the records for the period. Drop servers outside the period\\n # (we do this manually as we cannot limit the query to a period, only\\n # changes after start date).\\n self._process_servers_for_period(servers, extract_from, extract_to)\\n\\n # 3.- Get all the usages for the period\\n usages = self._get_usages(extract_from, extract_to)\\n # 4.- Iter over the results and\\n # This one will also generate accelerator records if GPU flavors\\n # are found.\\n self._process_usages_for_period(usages, extract_from, extract_to)\\n\\n return list(self.records.values()) + list(self.acc_records.values())\",\n \"def errorChecks(self):\\n stop_calculation = False\\n found_error = False\\n errors = {\\\"Info\\\": [], \\\"Critical\\\": []}\\n error_types = []\\n ori_images = 0\\n of_images = 0\\n depth_images = 0\\n back_of_images = 0\\n\\n if os.path.exists(self.savePathJoin(\\\"Images\\\")):\\n ori_images = len(\\n listDirectory(self.savePathJoin(\\\"Images\\\"), extension=\\\"png\\\")\\n )\\n # Check image folder\\n if self.img_exist and not os.path.exists(self.savePathJoin(\\\"Images\\\")):\\n if os.path.exists(self.user[\\\"Video\\\"]):\\n errors[\\\"Info\\\"].append(\\n \\\"Images folder {0} doesn't exist -> Recreate it and recalculate optical flow and depth estimations\\\".format(\\n self.savePathJoin(\\\"Images\\\")\\n )\\n )\\n error_types.append(\\\"NoImages\\\")\\n else:\\n stop_calculation = True\\n errors[\\\"Critical\\\"].append(\\n (\\n \\\"Images folder {0} and video file {1} don't exist -> Stopping run\\\".format(\\n self.savePathJoin(\\\"Images\\\"), self.user[\\\"Video\\\"]\\n )\\n )\\n )\\n elif self.img_exist and os.path.exists(self.user[\\\"Video\\\"]):\\n errors[\\\"Info\\\"].append(\\n \\\"Both the video {0} and Images folder {1} exist -> using Images folder by default\\\".format(\\n self.user[\\\"Video\\\"], self.savePathJoin(\\\"Images\\\")\\n )\\n )\\n elif not self.img_exist and not os.path.isfile(self.user[\\\"Video\\\"]):\\n stop_calculation = True\\n errors[\\\"Critical\\\"].append(\\n (\\n \\\"Images folder {0} and video file {1} don't exist -> Stopping run\\\".format(\\n self.savePathJoin(\\\"Images\\\"), self.user[\\\"Video\\\"]\\n )\\n )\\n )\\n\\n # Check video file\\n if self.user[\\\"Video\\\"] != \\\"\\\" and not os.path.isfile(self.user[\\\"Video\\\"]):\\n if os.path.exists(self.savePathJoin(\\\"Images\\\")):\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Video file {0} doesn't exist -> Using images in the Images folder instead\\\".format(\\n self.user[\\\"Video\\\"]\\n )\\n )\\n )\\n else:\\n stop_calculation = True\\n errors[\\\"Critical\\\"].append(\\n (\\n \\\"Images folder {0} and video file {1} don't exist -> Stopping run\\\".format(\\n self.savePathJoin(\\\"Images\\\"), self.user[\\\"Video\\\"]\\n )\\n )\\n )\\n elif os.path.isfile(self.user[\\\"Video\\\"]) and os.path.exists(\\n self.savePathJoin(\\\"Images\\\")\\n ):\\n pass\\n\\n # Check optical flow\\n if self.of_exist and not os.path.exists(self.savePathJoin(\\\"Of\\\")):\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Optical flow folder {0} doesn't exist -> Recalculating optical flow\\\".format(\\n self.savePathJoin(\\\"Of\\\")\\n )\\n )\\n )\\n error_types.append(\\\"NoOf\\\")\\n elif self.of_exist:\\n of_images = len(listDirectory(self.savePathJoin(\\\"Of\\\"), extension=\\\"png\\\"))\\n if of_images != ori_images - 1 and ori_images != 0:\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Optical flow image number {0} doesn't match video image number {1} - 1 -> Recalculating optical flow\\\".format(\\n of_images, ori_images\\n )\\n )\\n )\\n error_types.append(\\\"NoOf\\\")\\n\\n # Check backward optical flow\\n if self.back_of_exist and not os.path.exists(self.savePathJoin(\\\"Back_Of\\\")):\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Backward optical flow folder {0} doesn't exist -> Recalculating backward optical flow\\\".format(\\n self.savePathJoin(\\\"Back_Of\\\")\\n )\\n )\\n )\\n error_types.append(\\\"NoOf\\\")\\n elif self.back_of_exist:\\n back_of_images = len(\\n listDirectory(self.savePathJoin(\\\"Back_Of\\\"), extension=\\\"png\\\")\\n )\\n if back_of_images != of_images:\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Backward optical flow image number {0} doesn't match optical flow image number {1} -> Recalculating backward optical flow\\\".format(\\n back_of_images, of_images\\n )\\n )\\n )\\n error_types.append(\\\"NoOf\\\")\\n\\n # Check depth estimation\\n if self.depth_exist and not os.path.exists(self.savePathJoin(\\\"Depth\\\")):\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Depth folder {0} doesn't exist -> Recalculating depth\\\".format(\\n self.savePathJoin(\\\"Depth\\\")\\n )\\n )\\n )\\n error_types.append(\\\"NoDepth\\\")\\n elif self.depth_exist:\\n depth_images = len(\\n listDirectory(self.savePathJoin(\\\"Depth\\\"), extension=\\\"png\\\")\\n )\\n if depth_images != ori_images and ori_images != 0:\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Depth image number {0} doesn't match video image number {1} -> Recalculating depth\\\".format(\\n depth_images, ori_images\\n )\\n )\\n )\\n error_types.append(\\\"NoDepth\\\")\\n\\n # Check ground truth\\n if self.gt_exist and not os.path.isfile(self.user[\\\"GT\\\"]):\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Ground Truth file {0} doesn't exist -> File won't be used\\\".format(\\n self.user[\\\"GT\\\"]\\n )\\n )\\n )\\n error_types.append(\\\"NoGT\\\")\\n\\n # Check super pixel labels\\n if (\\n self.super_pixel_method != \\\"\\\"\\n and os.path.exists(\\n os.path.join(self.savePathJoin(\\\"Super_Pixel\\\"), self.super_pixel_method)\\n )\\n and ori_images != 0\\n and len(\\n listDirectory(\\n os.path.join(\\n self.savePathJoin(\\\"Super_Pixel\\\"), self.super_pixel_method\\n ),\\n extension=\\\".npy\\\",\\n )\\n )\\n != ori_images\\n ):\\n errors[\\\"Info\\\"].append(\\n (\\n \\\"Super pixel label number {0} doesn't match image number {1} -> Recalculating super pixel labels\\\".format(\\n len(\\n listDirectory(\\n os.path.join(\\n self.savePathJoin(\\\"Super_Pixel\\\"),\\n self.super_pixel_method,\\n ),\\n extension=\\\".npy\\\",\\n )\\n ),\\n ori_images,\\n )\\n )\\n )\\n error_types.append(\\\"LabelError\\\")\\n\\n # Check object detection\\n if self.ui.c_object_detection.isChecked() and os.path.exists(\\n self.savePathJoin(\\\"ObjectDetection\\\")\\n ):\\n if (\\n len(\\n listDirectory(\\n self.savePathJoin(\\\"ObjectDetection\\\"), extension=\\\".png\\\"\\n )\\n )\\n != ori_images\\n ):\\n errors[\\\"Info\\\"].append(\\n \\\"Object Detection image number {0} doesn't match image number of video {1} -> Recalculating object detection\\\".format(\\n len(\\n listDirectory(\\n self.savePathJoin(\\\"ObjectDetection\\\"), extension=\\\".png\\\"\\n )\\n ),\\n ori_images,\\n )\\n )\\n error_types.append(\\\"ObDetError\\\")\\n elif (\\n len(\\n listDirectory(\\n self.savePathJoin(\\\"ObjectDetection\\\"), extension=\\\".npy\\\"\\n )\\n )\\n != ori_images\\n ):\\n errors[\\\"Info\\\"].append(\\n \\\"Object Detection numpy array number {0} doesn't match image number of video {1} -> Recalculating object detection\\\".format(\\n len(\\n listDirectory(\\n self.savePathJoin(\\\"ObjectDetection\\\"), extension=\\\".npy\\\"\\n )\\n ),\\n ori_images,\\n )\\n )\\n error_types.append(\\\"ObDetError\\\")\\n\\n answer = \\\"\\\"\\n if len(errors[\\\"Info\\\"]) > 0 and len(errors[\\\"Critical\\\"]) == 0:\\n msg = QMessageBox()\\n msg.setIcon(QMessageBox.Information)\\n msg.setText(\\n \\\"Some calculations might not run the way you expect them.\\\\nIn show details check the right side of the arrows to see what will happen.\\\"\\n )\\n msg.setWindowTitle(\\\"Information\\\")\\n all_info = \\\"\\\"\\n for info in errors[\\\"Info\\\"]:\\n all_info += info + \\\"\\\\n\\\\n\\\"\\n msg.setDetailedText(all_info)\\n msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Abort)\\n answer = msg.exec_()\\n elif len(errors[\\\"Critical\\\"]) > 0:\\n msg = QMessageBox()\\n msg.setIcon(QMessageBox.Critical)\\n msg.setText(\\n \\\"Found critical error\\\\nCouldn't start run, see show details for more information\\\"\\n )\\n msg.setWindowTitle(\\\"Critical Error\\\")\\n all_info = \\\"\\\"\\n for info in errors[\\\"Critical\\\"]:\\n all_info += info + \\\"\\\\n\\\"\\n msg.setDetailedText(all_info)\\n msg.setStandardButtons(QMessageBox.Abort)\\n answer = msg.exec_()\\n\\n if answer != int(\\\"0x00040000\\\", 16):\\n for ty in error_types:\\n logging.info(\\\"Solve error: {0}\\\".format(ty))\\n if ty == \\\"NoImage\\\":\\n self.img_exist = False\\n self.of_exist = False\\n self.back_of_exist = False\\n self.depth_exist = False\\n elif ty == \\\"NoOf\\\":\\n self.of_exist = False\\n self.back_of_exist = False\\n elif ty == \\\"NoDepth\\\":\\n self.depth_exist = False\\n elif ty == \\\"NoGT\\\":\\n self.gt_exist = False\\n self.user[\\\"GT\\\"] = \\\"\\\"\\n elif ty == \\\"LabelError\\\":\\n self.create_super_pixel_label = True\\n shutil.rmtree(\\n os.path.join(\\n self.savePathJoin(\\\"Super_Pixel\\\"), self.super_pixel_method\\n )\\n )\\n elif ty == \\\"ObDetError\\\":\\n self.object_detection_dir_exist = False\\n shutil.rmtree(self.savePathJoin(\\\"ObjectDetection\\\"))\\n\\n return answer == int(\\\"0x00040000\\\", 16) or stop_calculation\",\n \"def HandleFiles(variables):\\n\\n # The template file is the html file into which we will write the\\n # data from the stats file, formatted correctly for the gviz_api.\\n template_file = open(variables[1], \\\"r\\\")\\n page_template = template_file.read()\\n template_file.close()\\n\\n # This is the path match pattern for finding stats files amongst\\n # all the other files it could be. eg: *.stt\\n file_pattern = variables[2]\\n\\n # This is the directory with files that we will use to do the comparison\\n # against.\\n baseline_dir = variables[3]\\n snrs = ''\\n filestable = {}\\n filestable['dsnr'] = ''\\n filestable['drate'] = ''\\n filestable['avg'] = ''\\n\\n # Go through each metric in the list.\\n for column in range(1,2):\\n\\n # Dirs is directories after the baseline to compare to the base.\\n dirs = variables[4:len(variables)]\\n\\n # Find the metric files in the baseline directory.\\n dir_list = sorted(fnmatch.filter(os.listdir(baseline_dir), file_pattern))\\n\\n for metric in ['avg','dsnr','drate']:\\n description = {\\\"file\\\": (\\\"string\\\", \\\"File\\\")}\\n\\n # Go through each directory and add a column header to our description.\\n countoverall = {}\\n sumoverall = {}\\n\\n for directory in dirs:\\n description[directory] = (\\\"number\\\", directory)\\n countoverall[directory] = 0\\n sumoverall[directory] = 0\\n\\n # Data holds the data for the visualization, name given comes from\\n # gviz_api sample code.\\n data = []\\n for filename in dir_list:\\n row = {'file': splitext(basename(filename))[0] }\\n baseline_file_name = baseline_dir + \\\"/\\\" + filename\\n\\n # Read the metric file from each of the directories in our list.\\n for directory in dirs:\\n metric_file_name = directory + \\\"/\\\" + filename\\n\\n # If there is a metric file in the current directory, open it\\n # and calculate its overall difference between it and the baseline\\n # directory's metric file.\\n if os.path.isfile(metric_file_name):\\n overall = FileBetter(baseline_file_name, metric_file_name,\\n column, metric)\\n row[directory] = overall\\n\\n sumoverall[directory] += overall\\n countoverall[directory] += 1\\n\\n data.append(row)\\n\\n # Add the overall numbers.\\n row = {\\\"file\\\": \\\"OVERALL\\\" }\\n if countoverall[directory]:\\n for directory in dirs:\\n row[directory] = sumoverall[directory] / countoverall[directory]\\n data.append(row)\\n\\n # write the tables out\\n data_table = gviz_api.DataTable(description)\\n data_table.LoadData(data)\\n\\n filestable[metric] = ( filestable[metric] + \\\"filestable_\\\" + metric +\\n \\\"[\\\" + str(column) + \\\"]=\\\" + data_table.ToJSon()\\n + \\\"\\\\n\\\" )\\n\\n filestable_avg = filestable['avg']\\n filestable_dpsnr = filestable['dsnr']\\n filestable_drate = filestable['drate']\\n\\n # Now we collect all the data for all the graphs. First the column\\n # headers which will be Datarate and then each directory.\\n columns = (\\\"datarate\\\",baseline_dir)\\n description = {\\\"datarate\\\":(\\\"number\\\", \\\"Datarate\\\")}\\n for directory in dirs:\\n description[directory] = (\\\"number\\\", directory)\\n\\n description[baseline_dir] = (\\\"number\\\", baseline_dir)\\n\\n snrs = snrs + \\\"snrs[\\\" + str(column) + \\\"] = [\\\"\\n\\n # Now collect the data for the graphs, file by file.\\n for filename in dir_list:\\n\\n data = []\\n\\n # Collect the file in each directory and store all of its metrics\\n # in the associated gviz metrics table.\\n all_dirs = dirs + [baseline_dir]\\n for directory in all_dirs:\\n\\n metric_file_name = directory + \\\"/\\\" + filename\\n if not os.path.isfile(metric_file_name):\\n continue\\n\\n # Read and parse the metrics file storing it to the data we'll\\n # use for the gviz_api.Datatable.\\n metrics = ParseMetricFile(metric_file_name, column)\\n for bitrate, metric in metrics:\\n data.append({\\\"datarate\\\": bitrate, directory: metric})\\n\\n data_table = gviz_api.DataTable(description)\\n data_table.LoadData(data)\\n snrs = snrs + \\\"'\\\" + data_table.ToJSon(\\n columns_order=tuple([\\\"datarate\\\",baseline_dir]+dirs)) + \\\"',\\\"\\n\\n snrs = snrs + \\\"]\\\\n\\\"\\n\\n formatters = \\\"\\\"\\n for i in range(len(dirs)):\\n formatters = \\\"%s formatter.format(better, %d);\\\" % (formatters, i+1)\\n\\n print FillForm(page_template, vars())\\n return\",\n \"def nonsidereal_pointing_updates(self):\\n obs = np.array(self.info['ObservationID'])\\n all_date_obs = np.array(self.info['date_obs'])\\n all_time_obs = np.array(self.info['time_obs'])\\n all_exposure = np.array(self.info['exposure'])\\n all_apertures = np.array(self.info['aperture'])\\n tracking = np.array(self.info['Tracking'])\\n targs = np.array(self.info['TargetID'])\\n inst = np.array(self.info['Instrument'])\\n ra_from_pointing_file = np.array(self.info['ra'])\\n dec_from_pointing_file = np.array(self.info['dec'])\\n nonsidereal_index = np.where(np.array(tracking) == 'non-sidereal')\\n all_nonsidereal_targs = targs[nonsidereal_index]\\n all_nonsidereal_instruments = inst[nonsidereal_index]\\n\\n # Get a list of the unique (target, instrument) combinations for\\n # non-sidereal observations\\n inst_targs = [[t, i] for t, i in zip(all_nonsidereal_targs, all_nonsidereal_instruments)]\\n ctr = Counter(tuple(x) for x in inst_targs)\\n unique = [list(key) for key in ctr.keys()]\\n\\n # Check that all non-sidereal targets have catalogs associated with them\\n #for targ, inst in zip(nonsidereal_targs, nonsidereal_instruments):\\n for element in unique:\\n targ, inst = element\\n\\n # Skip unsupported instruments\\n if inst in ['NIRSpec', 'MIRI']:\\n continue\\n\\n ns_catalog = get_nonsidereal_catalog_name(self.catalogs, targ, inst)\\n catalog_table, pos_in_xy, vel_in_xy = read_nonsidereal_catalog(ns_catalog)\\n\\n # If the ephemeris_file column is present but equal to 'none', then\\n # remove the column\\n if 'ephemeris_file' in catalog_table.colnames:\\n if catalog_table['ephemeris_file'][0].lower() == 'none':\\n catalog_table.remove_column('ephemeris_file')\\n\\n if 'ephemeris_file' in catalog_table.colnames:\\n ephemeris_file = catalog_table['ephemeris_file'][0]\\n ra_ephem, dec_ephem = ephemeris_tools.get_ephemeris(ephemeris_file)\\n\\n # Find the observations that use this target\\n exp_index_this_target = targs == targ\\n obs_this_target = np.unique(obs[exp_index_this_target])\\n\\n # Loop over observations\\n for obs_name in obs_this_target:\\n\\n # Get date/time for every exposure\\n obs_exp_indexes = np.where(obs == obs_name)\\n obs_dates = all_date_obs[obs_exp_indexes]\\n obs_times = all_time_obs[obs_exp_indexes]\\n exposures = all_exposure[obs_exp_indexes]\\n apertures = all_apertures[obs_exp_indexes]\\n unique_apertures = np.unique(apertures)\\n\\n start_dates = []\\n for date_obs, time_obs in zip(obs_dates, obs_times):\\n ob_time = '{}T{}'.format(date_obs, time_obs)\\n try:\\n start_dates.append(datetime.datetime.strptime(ob_time, '%Y-%m-%dT%H:%M:%S'))\\n except ValueError:\\n start_dates.append(datetime.datetime.strptime(ob_time, '%Y-%m-%dT%H:%M:%S.%f'))\\n\\n if 'ephemeris_file' in catalog_table.colnames:\\n all_times = [ephemeris_tools.to_timestamp(elem) for elem in start_dates]\\n\\n # Create list of positions for all frames\\n try:\\n ra_target = ra_ephem(all_times)\\n dec_target = dec_ephem(all_times)\\n\\n except ValueError:\\n raise ValueError((\\\"Observation dates ({} - {}) are not present within the ephemeris file {}\\\"\\n .format(start_dates[0], start_dates[-1], ephemeris_file)))\\n else:\\n if not pos_in_xy:\\n # Here we assume that the source (and aperture reference location)\\n # is located at the given RA, Dec at the start of the first exposure\\n base_ra, base_dec = parse_RA_Dec(catalog_table['x_or_RA'].data[0], catalog_table['y_or_Dec'].data[0])\\n ra_target = [base_ra]\\n dec_target = [base_dec]\\n\\n ra_vel = catalog_table['x_or_RA_velocity'].data[0]\\n dec_vel = catalog_table['y_or_Dec_velocity'].data[0]\\n\\n # If the source velocity is given in units of pixels/hour, then we need\\n # to multiply this by the appropriate pixel scale.\\n if vel_in_xy:\\n if len(unique_apertures) > 1:\\n if inst.lower() == 'nircam':\\n det_ints = [int(ele.split('_')[0][-1]) for ele in unique_apertures]\\n # If the observation contains NIRCam exposures in both the LW and\\n # SW channels, then the source velocity is ambiguous due to the\\n # different pixel scales. In that case, raise an exception.\\n if np.min(det_ints) < 5 and np.max(det_ints) == 5:\\n raise ValueError(('Non-sidereal source {} has no ephemeris file, and a velocity that '\\n 'is specified in units of pixels/hour in the source catalog. '\\n 'Since observation {} contains NIRCam apertures within both the '\\n 'SW and LW channels (which have different pixel scales), '\\n 'Mirage does not know which pixel scale to use '\\n 'when placing the source.'.format(targ, obs_name)))\\n\\n # In this case, there is a well-defined pixel scale, so we can translate\\n # velocities to units of arcsec/hour\\n siaf = pysiaf.Siaf(inst)[unique_apertures[0]]\\n ra_vel *= siaf.XSciScale\\n dec_vel *= siaf.XSciScale\\n\\n # Calculate RA, Dec for each exposure given the velocities\\n for ob_date in start_dates[1:]:\\n delta_time = ob_date - start_dates[0]\\n delta_ra = ra_vel * delta_time.total_seconds() / 3600.\\n delta_dec = dec_vel * delta_time.total_seconds() / 3600.\\n ra_target.append(base_ra + delta_ra)\\n dec_target.append(base_dec + delta_dec)\\n\\n else:\\n # Source location comes from the source catalog and is in units of pixels.\\n # This can't really be supported, since we don't know which detector the\\n # location is for. We could proceed, but Mirage would then put the source\\n # pixel (x, y) in every aperture/detector.\\n if len(unique_apertures) > 1:\\n raise ValueError(('Non-sidereal source {} has no ephemeris file, and a location that '\\n 'is specified in units of detector pixels in the source catalog. '\\n 'Since observation {} contains multiple apertures (implying different '\\n 'coordinate systems), Mirage does not know which coordinate system '\\n 'to use when placing the source.'.format(targ, obs_name)))\\n\\n # If there is only a single aperture associated with the observation,\\n # then we can proceed. We first need to translate the given x, y position\\n # to RA, Dec\\n base_ra, base_dec = aperture_xy_to_radec(catalog_table['x_or_RA'].data[0],\\n catalog_table['y_or_Dec'].data[0],\\n inst, aperture, fiducial_ra, fiducial_dec, pav3)\\n\\n\\n ra_from_pointing_file[obs_exp_indexes] = ra_target\\n dec_from_pointing_file[obs_exp_indexes] = dec_target\\n\\n self.info['TargetRA'] = ra_from_pointing_file\\n self.info['TargetDec'] = dec_from_pointing_file\\n\\n # Need to update these values (which come from the pointing file)\\n # so that below we can adjust them for the different detectors/apertures\\n self.info['ra'] = [np.float64(ele) for ele in ra_from_pointing_file]\\n self.info['dec'] = [np.float64(ele) for ele in dec_from_pointing_file]\\n\\n # These go into the pointing in the yaml file\\n self.info['ra_ref'] = ra_from_pointing_file\\n self.info['dec_ref'] = dec_from_pointing_file\",\n \"def compare_analysis_to_golden(log_filename: str, log_file_path: str) -> None:\\n\\n golden_result_filename = os.path.join(\\n log_file_path, '{:s}_golden.json'.format(os.path.splitext(log_filename)[0]))\\n\\n with TemporaryDirectory() as tmp_dir:\\n\\n tmp_log_filename = os.path.join(tmp_dir, os.path.basename(log_filename))\\n\\n os.system('cp {:s} {:s}'.format(log_filename, tmp_log_filename))\\n\\n assert os.path.exists(tmp_log_filename), '{:s} does not exist.'.format(tmp_log_filename)\\n\\n process_logdata_ekf(tmp_log_filename, plot=False)\\n\\n analysis_result_filename = os.path.join(\\n tmp_dir, '{:s}.json'.format(os.path.splitext(tmp_log_filename)[0]))\\n\\n assert os.path.exists(analysis_result_filename), '{:s} does not exist.'.format(\\n analysis_result_filename)\\n\\n with open(analysis_result_filename, 'r') as file:\\n analysis_results = json.load(file)\\n\\n with open(golden_result_filename, 'r') as file:\\n golden_results = json.load(file)\\n\\n print('comparing analysis to golden results')\\n\\n for local_analysis_check, golden_analysis_check in zip(analysis_results, golden_results):\\n print('{:s}'.format(local_analysis_check['type']))\\n compare_check_analysis_result_ground_truth(\\n local_analysis_check, golden_analysis_check,\\n os.path.splitext(os.path.basename(tmp_log_filename))[0])\",\n \"def diff(s0, s1):\\n from difflib import ndiff\\n lst0 = s0.split(\\\"\\\\n\\\")\\n lst1 = s1.split(\\\"\\\\n\\\")\\n report = '\\\\n'.join(ndiff(lst0, lst1))\\n return report\",\n \"def diff(s0, s1):\\n from difflib import ndiff\\n lst0 = s0.split(\\\"\\\\n\\\")\\n lst1 = s1.split(\\\"\\\\n\\\")\\n report = '\\\\n'.join(ndiff(lst0, lst1))\\n return report\",\n \"def upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison(self):\\n\\n data_label=\\\"20170511_230901\\\"\\n ref_label=\\\"20170507_135726\\\"\\n ref_filename=os.path.join(self.plots_data_dir,\\n 'flowmap_ICE5G_data_ALG4_sinkless_downscaled_ls_mask_0k_upscale'\\n '_rdirs_{0}_updated.nc'.format(ref_label))\\n data_filename=os.path.join(self.plots_data_dir,\\n 'flowmap_ICE5G_and_tarasov_upscaled_srtm30plus_north_america_only_data_ALG4_sinkless'\\n '_downscaled_ls_mask_0k_upscale_rdirs_' + data_label + '_updated.nc')\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_extract_ls_mask_from_corrected_\\\"\\n \\\"HD_rdirs_20160504_142435.nc\\\")\\n corrected_hd_rdirs_rmouthoutflow_file = os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE5G_data_ALG4_sinkless_downscaled_ls_mask_0k_upscale_rdirs\\\"\\n \\\"_{0}_updated.nc\\\".format(ref_label))\\n upscaled_rdirs_rmouthoutflow_file = os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE5G_and_tarasov_upscaled_srtm30plus_north_america_only_\\\"\\n \\\"data_ALG4_sinkless_\\\"\\n \\\"downscaled_ls_mask_0k_upscale_rdirs_\\\" + data_label + \\\"_updated.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n \\\"catchmentmap_ICE5G_data_ALG4_\\\"\\n \\\"sinkless_downscaled_ls_mask_0k_upscale_rdirs_{0}_updated.nc\\\"\\\\\\n .format(ref_label),\\n data_catchment_filename=\\\"catchmentmap_ICE5G_and_tarasov_upscaled_\\\"\\n \\\"srtm30plus_north_america_only_data_ALG4_sinkless_downscaled_ls_\\\"\\n \\\"mask_0k_upscale_rdirs_\\\" + data_label + \\\"_updated.nc\\\",\\n ref_rdirs_filename=\\\"upscaled_rdirs_ICE5G_data\\\"\\n \\\"_ALG4_sinkless_downscaled_\\\"\\n \\\"ls_mask_0k_upscale_rdirs_{0}_updated.nc\\\".format(ref_label),\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n corrected_hd_rdirs_rmouthoutflow_file,\\n data_rmouth_outflows_filename=\\\\\\n upscaled_rdirs_rmouthoutflow_file,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=50,flip_data=False,\\n rotate_data=True,flip_ref=False,rotate_ref=True,\\n lsmask_has_same_orientation_as_ref=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"Reference\\\",\\n matching_parameter_set='magnitude_extensive',\\n use_single_color_for_discrepancies=True,\\n second_datasource_name=\\\"Data\\\",grid_type='HD')\",\n \"def calculate(self, data, *args, **kwargs):\\n \\n # Sets up priority queue, where data is prioritized by date\\n queue = []\\n \\n # Sets up data dictionaries that will be used to contain calculated data\\n severity_data = OrderedDict()\\n status_data = OrderedDict()\\n current_state = { }\\n \\n # List of fields used\\n fields = [PROJECT, TRANS, STATUS, PRIORITY]\\n \\n # Populates priority queue with appropriate data\\n for key, param_data in data.iteritems():\\n # Grabs param_data fields\\n priority = param_data.get(PRIORITY, None)\\n hist = param_data.get(HIST, None)\\n proj = param_data.get(PROJECT, self.project)\\n \\n # Adds the historical statuses of the current JIRA item to the queue\\n if (hist):\\n for i, date in enumerate(hist[TRANS]):\\n heapq.heappush(queue, (date, proj, key, hist[NEW][i], priority))\\n \\n # Iterates through dates to populate status and severity data dictionaries\\n if (queue):\\n earliest = queue[0][0]\\n for date in get_historical_dates(earliest, self.extraction_day, False):\\n # Pops items off queue until queue is empty or date limit is reached\\n while(queue and queue[0][0].date() <= date):\\n curr, proj, key, status, priority = heapq.heappop(queue)\\n \\n # Maps the key's current parameters, overwriting previous mapping\\n current_state[key] = { }\\n for field, value in zip(fields, [proj, curr, status, priority]):\\n current_state[key][field] = value\\n \\n # Sets severity and status metric data at the given date\\n severity_data[date] = self._get_severity_data(current_state)\\n status_data[date] = self._get_status_data(current_state)\\n \\n # Gets age data separately from status and severity\\n age_map = self._get_average_age_data(data)\\n \\n return severity_data, status_data, age_map\",\n \"def calculate_diagnostic_vars(self):\\n pass\",\n \"def perform_reference(self):\\n # Phase 1: Estimate the true signal mean with robust referencing\\n self.robust_reference()\\n if self.noisy_channels[\\\"bad_all\\\"]:\\n self.raw.info[\\\"bads\\\"] = self.noisy_channels[\\\"bad_all\\\"]\\n self.raw.interpolate_bads()\\n self.reference_signal = (\\n np.nanmean(self.raw.get_data(picks=self.reference_channels), axis=0) * 1e6\\n )\\n rereferenced_index = [\\n self.ch_names_eeg.index(ch) for ch in self.rereferenced_channels\\n ]\\n self.EEG = self.remove_reference(\\n self.EEG, self.reference_signal, rereferenced_index\\n )\\n\\n # Phase 2: Find the bad channels and interpolate\\n self.raw._data = self.EEG * 1e-6\\n noisy_detector = NoisyChannels(self.raw)\\n noisy_detector.find_all_bads(ransac=self.ransac)\\n\\n # Record Noisy channels and EEG before interpolation\\n self.bad_before_interpolation = noisy_detector.get_bads(verbose=True)\\n self.EEG_before_interpolation = self.EEG.copy()\\n\\n bad_channels = _union(self.bad_before_interpolation, self.unusable_channels)\\n self.raw.info[\\\"bads\\\"] = bad_channels\\n self.raw.interpolate_bads()\\n reference_correct = (\\n np.nanmean(self.raw.get_data(picks=self.reference_channels), axis=0) * 1e6\\n )\\n self.EEG = self.raw.get_data() * 1e6\\n self.EEG = self.remove_reference(\\n self.EEG, reference_correct, rereferenced_index\\n )\\n # reference signal after interpolation\\n self.reference_signal_new = self.reference_signal + reference_correct\\n # MNE Raw object after interpolation\\n self.raw._data = self.EEG * 1e-6\\n\\n # Still noisy channels after interpolation\\n self.interpolated_channels = bad_channels\\n noisy_detector = NoisyChannels(self.raw)\\n noisy_detector.find_all_bads(ransac=self.ransac)\\n self.still_noisy_channels = noisy_detector.get_bads()\\n self.raw.info[\\\"bads\\\"] = self.still_noisy_channels\\n return self\",\n \"def lf_abnormal_interp_with_slowing(report):\\n if 'interpretation' in report.sections.keys():\\n interpretation = report.sections['interpretation']\\n interp_text = interpretation['text']\\n return abnormal_interp_with_slowing(interp_text)\\n elif 'summary' in report.sections:\\n return abnormal_interp_with_slowing(report.sections['summary']['text'])\\n elif 'findings' in report.sections: # fall back to look in the findings \\n if 'summary' in report.sections['findings']: # fall back to look for a summary instead\\n return abnormal_interp_with_slowing(report.sections['findings']['summary'])\\n if 'impression' in report.sections['findings']:\\n return abnormal_interp_with_slowing(report.sections['findings']['impression'])\\n return ABSTAIN_VAL\\n elif 'narrative' in report.sections: # fall back to look in the findings \\n ky = 'narrative'\\n if 'summary' in report.sections[ky]: # fall back to look for a summary instead\\n return abnormal_interp_with_slowing(report.sections[ky]['summary'])\\n if 'impression' in report.sections[ky]:\\n return abnormal_interp_with_slowing(report.sections[ky]['impression'])\\n # could try running on all of findings but would really need to check then\\n \\n return ABSTAIN_VAL \\n else:\\n return ABSTAIN_VAL\",\n \"def get_files_diff(self, current_files_data):\\n if self.saved_files_data:\\n saved_files_paths, saved_files_hashes = zip(*self.saved_files_data.items())\\n else:\\n saved_files_paths, saved_files_hashes = [], []\\n if current_files_data:\\n current_files_paths, current_files_hashes = zip(*current_files_data.items())\\n else:\\n current_files_paths, current_files_hashes = [], []\\n\\n missing_files_paths = list(set(saved_files_paths).difference(set(current_files_paths)))\\n missing_files_hashes = [self.saved_files_data[path] for path in missing_files_paths]\\n added_files_paths = list(set(current_files_paths).difference(set(saved_files_paths)))\\n added_files_hashes = [current_files_data[path] for path in added_files_paths]\\n\\n # get moved files paths\\n moved_files_hashes = list(set(missing_files_hashes).intersection(set(added_files_hashes)))\\n moved_files_paths = [\\n json.dumps({\\n 'from': self.get_file_path_by_hash(self.saved_files_data, hash_),\\n 'to': self.get_file_path_by_hash(current_files_data, hash_)\\n }) for hash_ in moved_files_hashes\\n ]\\n\\n # get missing files paths\\n missing_files_paths = [ # remove \\\"moved\\\" files paths\\n self.get_file_path_by_hash(self.saved_files_data, hash_)\\n for hash_ in missing_files_hashes if hash_ not in moved_files_hashes\\n ]\\n\\n # get added files paths\\n added_files_paths = [ # remove \\\"moved\\\" files paths\\n self.get_file_path_by_hash(current_files_data, hash_)\\n for hash_ in added_files_hashes if hash_ not in moved_files_hashes\\n ]\\n\\n # get edited files paths\\n remained_files_paths = list(set(saved_files_paths).intersection(set(current_files_paths)))\\n for file_path in remained_files_paths:\\n if self.saved_files_data[file_path] != current_files_data[file_path]: # compare hashes\\n missing_files_paths.append(file_path)\\n added_files_paths.append(file_path)\\n\\n if any([missing_files_paths, added_files_paths, moved_files_paths]):\\n self.saved_files_data = current_files_data\\n\\n return missing_files_paths, added_files_paths, moved_files_paths\",\n \"def report_unknown_indel_results(allele1, allele2, \\\\\\n five_prime_diff, five_prime_variant_len, three_prime_diff, three_prime_variant_len):\\n \\n if five_prime_diff == 'error - cannot compare' or three_prime_diff == 'error - cannot compare':\\n relative_sequence_alignment = '{} and {} cannot be compared using the MSF file'.format(allele1, allele2)\\n return relative_sequence_alignment\\n \\n if five_prime_diff == 'deletion':\\n if three_prime_diff == 'deletion':\\n relative_sequence_alignment = \\\"{} is a superset of {}; 5' end {}bp overhang; 3' end {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len)\\n\\n elif three_prime_diff == 'insertion':\\n relative_sequence_alignment = \\\"{} has a staggered 3' end overlap with {}; 5' end {}bp overhang; 3' {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len) \\n \\n elif three_prime_diff == 'no diff':\\n relative_sequence_alignment = \\\"{} is a superset of {}; 5' end {}bp overhang; 3' end {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len) \\n \\n elif five_prime_diff == 'insertion':\\n if three_prime_diff == 'insertion':\\n relative_sequence_alignment = \\\"{} is a subset of {}; 5' end {}bp overhang; 3' end {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len) \\n \\n elif three_prime_diff == 'deletion':\\n relative_sequence_alignment = \\\"{} has a staggered 5' end overlap with {}; 5' {}bp overhang; 3' end {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len) \\n \\n elif three_prime_diff == 'no diff':\\n relative_sequence_alignment = \\\"{} is a subset of {}; 5' end {}bp overhang; 3' end {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len) \\n \\n \\n elif five_prime_diff == 'no diff':\\n if three_prime_diff == 'deletion':\\n relative_sequence_alignment = \\\"{} is a superset of {}; 5' end {}bp overhang; 3' end {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len) \\n \\n elif three_prime_diff == 'insertion':\\n relative_sequence_alignment = \\\"{} is a subset of {}; 5' end {}bp overhang; 3' end {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len) \\n \\n elif three_prime_diff == 'no diff':\\n relative_sequence_alignment = \\\"{} is aligned with {}; 5' end {}bp overhang; 3' end {}bp overhang\\\".\\\\\\n format(allele1, allele2, five_prime_variant_len, three_prime_variant_len) \\n\\n\\n \\n return relative_sequence_alignment\",\n \"def lint(self):\\n report = OrderedDict()\\n\\n for index, slice in self.slices.iterrows():\\n inputs, outputs = create_activations(slice)\\n inf = inputs[0].format[:4]\\n outf = outputs[0].format[:4]\\n if inf != outf:\\n mitigation = \\\"\\\"\\n if \\\"INT8\\\" in [inf, outf]:\\n mitigation = \\\"Consider adding quantization around float operations.\\\"\\n report[slice.Name] = OrderedDict({\\n 'name': slice.Name,\\n 'type conversion': f\\\"{inf} -> {outf}\\\",\\n 'shape conversion': f\\\"{inputs[0].shape} -> {outputs[0].shape}\\\",\\n 'hazard': \\\"Slice layer is converting operand data type.\\\",\\n 'mitigation': mitigation,\\n 'help': \\\"Conversions between float32 and float16 are a red \\\"\\n \\\"flag, as are conversions between float32/16 <=> INT8.\\\"\\n })\\n\\n df = pd.DataFrame.from_dict(report, orient='index')\\n return df\",\n \"def compute(cls, observation, prediction, distances):\\n\\n errors = collections.OrderedDict()\\n\\n for i in range (0, len(distances)):\\n if 'mean_AP1_amp_strong_propagating_at_'+str(distances[i])+'um' in observation.keys() or 'mean_AP1_amp_weak_propagating_at_'+str(distances[i])+'um' in observation.keys():\\n p_value = prediction['model_AP1_amp_at_'+str(distances[i])+'um']['mean']\\n o_mean = observation['mean_AP1_amp_strong_propagating_at_'+str(distances[i])+'um']\\n o_std = observation['std_AP1_amp_strong_propagating_at_'+str(distances[i])+'um']\\n\\n try:\\n error = abs(p_value - o_mean)/o_std\\n error = assert_dimensionless(error)\\n except (TypeError,AssertionError) as e:\\n error = e\\n errors['AP1_amp_strong_propagating_at_'+str(distances[i])] = error\\n\\n\\n o_mean = observation['mean_AP1_amp_weak_propagating_at_'+str(distances[i])+'um']\\n o_std = observation['std_AP1_amp_weak_propagating_at_'+str(distances[i])+'um']\\n\\n try:\\n error = abs(p_value - o_mean)/o_std\\n error = assert_dimensionless(error)\\n except (TypeError,AssertionError) as e:\\n error = e\\n errors['AP1_amp_weak_propagating_at_'+str(distances[i])] = error\\n\\n else:\\n p_value = prediction['model_AP1_amp_at_'+str(distances[i])+'um']['mean']\\n o_mean = observation['mean_AP1_amp_at_'+str(distances[i])+'um']\\n o_std = observation['std_AP1_amp_at_'+str(distances[i])+'um']\\n\\n try:\\n error = abs(p_value - o_mean)/o_std\\n error = assert_dimensionless(error)\\n except (TypeError,AssertionError) as e:\\n error = e\\n errors['AP1_amp_at_'+str(distances[i])] = error\\n\\n for i in range (0, len(distances)): # to keep better order: first all AP1, then all APlast\\n p_value_l = prediction['model_APlast_amp_at_'+str(distances[i])+'um']['mean']\\n o_mean_l = observation['mean_APlast_amp_at_'+str(distances[i])+'um']\\n o_std_l = observation['std_APlast_amp_at_'+str(distances[i])+'um']\\n\\n try:\\n error_l = abs(p_value_l - o_mean_l)/o_std_l\\n error_l = assert_dimensionless(error_l)\\n except (TypeError,AssertionError) as e:\\n error_l = e\\n errors['APlast_amp_at_'+str(distances[i])] = error_l\\n\\n score_sum_strong_propagating = 0.0\\n score_sum_weak_propagating = 0.0\\n\\n for key, value in errors.iteritems():\\n if 'strong' not in key:\\n score_sum_weak_propagating += value\\n for key, value in errors.iteritems():\\n if 'weak' not in key:\\n score_sum_strong_propagating += value\\n return [score_sum_strong_propagating, score_sum_weak_propagating], errors\",\n \"def _get_diff2_data(request, ps_left_id, ps_right_id, patch_id, context,\\n column_width, patch_filename=None):\\n ps_left = models.PatchSet.get_by_id(int(ps_left_id), parent=request.issue.key)\\n if ps_left is None:\\n return HttpTextResponse(\\n 'No patch set exists with that id (%s)' % ps_left_id, status=404)\\n ps_left.issue_key = request.issue.key\\n ps_right = models.PatchSet.get_by_id(\\n int(ps_right_id), parent=request.issue.key)\\n if ps_right is None:\\n return HttpTextResponse(\\n 'No patch set exists with that id (%s)' % ps_right_id, status=404)\\n ps_right.issue_key = request.issue.key\\n if patch_id is not None:\\n patch_right = models.Patch.get_by_id(int(patch_id), parent=ps_right.key)\\n else:\\n patch_right = None\\n if patch_right is not None:\\n patch_right.patchset_key = ps_right.key\\n if patch_filename is None:\\n patch_filename = patch_right.filename\\n # Now find the corresponding patch in ps_left\\n patch_left = models.Patch.query(\\n models.Patch.patchset_key == ps_left.key,\\n models.Patch.filename == patch_filename).get()\\n\\n if patch_left:\\n try:\\n new_content_left = patch_left.get_patched_content()\\n except FetchError as err:\\n return HttpTextResponse(str(err), status=404)\\n lines_left = new_content_left.lines\\n elif patch_right:\\n lines_left = patch_right.get_content().lines\\n else:\\n lines_left = []\\n\\n if patch_right:\\n try:\\n new_content_right = patch_right.get_patched_content()\\n except FetchError as err:\\n return HttpTextResponse(str(err), status=404)\\n lines_right = new_content_right.lines\\n elif patch_left:\\n lines_right = patch_left.get_content().lines\\n else:\\n lines_right = []\\n\\n rows = engine.RenderDiff2TableRows(request,\\n lines_left, patch_left,\\n lines_right, patch_right,\\n context=context,\\n colwidth=column_width)\\n rows = list(rows)\\n if rows and rows[-1] is None:\\n del rows[-1]\\n\\n return dict(patch_left=patch_left, patch_right=patch_right,\\n ps_left=ps_left, ps_right=ps_right, rows=rows)\",\n \"def analyze_prior_results(self, analysis_source):\\n #TODO: move to iota_run.py\\n\\n from iota.components.iota_analysis import Analyzer\\n from libtbx import easy_pickle as ep\\n\\n if os.path.isdir(analysis_source):\\n int_folder = os.path.abspath(analysis_source)\\n else:\\n try:\\n int_folder = os.path.abspath(os.path.join(os.curdir,\\n 'integration/{}/image_objects'.format(analysis_source)))\\n except ValueError:\\n int_folder = None\\n print ('Run #{} not found'.format(analysis_source))\\n\\n if os.path.isdir(int_folder):\\n with prog_message('Analyzing Results'):\\n int_list = [os.path.join(int_folder, i) for i in os.listdir(int_folder)]\\n img_objects = [ep.load(i) for i in int_list if i.endswith('.int')]\\n\\n self.logfile = os.path.abspath(os.path.join(int_folder, 'iota.log'))\\n self.viz_base = os.path.join('/'.join(int_folder.split('/')),\\n 'vizualization')\\n\\n self.params.analysis.cluster_write_files=False\\n\\n analysis = Analyzer(self, img_objects, self.iver)\\n analysis.print_results()\\n analysis.unit_cell_analysis()\\n analysis.print_summary(write_files=False)\\n else:\\n print ('No results found in {}'.format(int_folder))\",\n \"def _restore_sampler_from_reporter(self, reporter):\\n # Read the last iteration reported to ensure we don't include junk\\n # data written just before a crash.\\n logger.debug(\\\"Reading storage file {}...\\\".format(reporter.filepath))\\n metadata = reporter.read_dict('metadata')\\n thermodynamic_states, unsampled_states = reporter.read_thermodynamic_states()\\n\\n def _read_options(check_iteration):\\n internal_sampler_states = reporter.read_sampler_states(iteration=check_iteration)\\n internal_state_indices = reporter.read_replica_thermodynamic_states(iteration=check_iteration)\\n internal_energy_thermodynamic_states, internal_neighborhoods, internal_energy_unsampled_states = \\\\\\n reporter.read_energies(iteration=check_iteration)\\n internal_n_accepted_matrix, internal_n_proposed_matrix = \\\\\\n reporter.read_mixing_statistics(iteration=check_iteration)\\n\\n # Search for last cached free energies only if online analysis is activated.\\n internal_last_mbar_f_k, internal_last_err_free_energy = None, None\\n if self.online_analysis_interval is not None:\\n online_analysis_info = self._read_last_free_energy(reporter, check_iteration)\\n try:\\n internal_last_mbar_f_k, (_, internal_last_err_free_energy) = online_analysis_info\\n except TypeError:\\n # Trap case where online analysis is set but not run yet and (_, ...) = None is not iterable\\n pass\\n return (internal_sampler_states, internal_state_indices, internal_energy_thermodynamic_states,\\n internal_neighborhoods, internal_energy_unsampled_states, internal_n_accepted_matrix,\\n internal_n_proposed_matrix, internal_last_mbar_f_k, internal_last_err_free_energy)\\n\\n # Keep trying to resume further and further back from the most recent checkpoint back\\n checkpoints = reporter.read_checkpoint_iterations()\\n checkpoint_reverse_iter = iter(checkpoints[::-1])\\n while True:\\n try:\\n checkpoint = next(checkpoint_reverse_iter)\\n output_data = _read_options(checkpoint)\\n # Found data, can escape loop\\n break\\n except StopIteration:\\n raise self._throw_restoration_error(\\\"Attempting to restore from any checkpoint failed. \\\"\\n \\\"Either your data is fully corrupted or something has gone very \\\"\\n \\\"wrong to see this message. \\\"\\n \\\"Please open an issue on the GitHub issue tracker if you see this!\\\")\\n except Exception as err:\\n raise err\\n # Trap all other errors caught by the load process\\n continue\\n\\n if checkpoint < checkpoints[-1]:\\n logger.warning(\\\"Could not use most recent checkpoint at {}, instead pulled from {}\\\".format(checkpoints[-1],\\n checkpoint))\\n (sampler_states, state_indices, energy_thermodynamic_states, neighborhoods, energy_unsampled_states,\\n n_accepted_matrix, n_proposed_matrix, last_mbar_f_k, last_err_free_energy) = output_data\\n # Assign attributes.\\n self._iteration = int(checkpoint) # The int() can probably be removed when pinned to NetCDF4 >=1.4.0\\n self._thermodynamic_states = thermodynamic_states\\n self._unsampled_states = unsampled_states\\n self._sampler_states = sampler_states\\n self._replica_thermodynamic_states = np.array(state_indices)\\n self._energy_thermodynamic_states = energy_thermodynamic_states\\n self._neighborhoods = neighborhoods\\n self._energy_unsampled_states = energy_unsampled_states\\n self._n_accepted_matrix = np.array(n_accepted_matrix)\\n self._n_proposed_matrix = np.array(n_proposed_matrix)\\n self._metadata = metadata\\n\\n self._last_mbar_f_k = last_mbar_f_k\\n self._last_err_free_energy = last_err_free_energy\\n\\n # initialize timing dictionary\\n self._timing_data = dict()\\n\\n # Initialize context caches\\n self._initialize_context_caches()\",\n \"def check_file_locations(store: dict[str, Any]) -> ValidationStepResult:\\n success: bool = True\\n filtered_files: dict[PullRequestFileType, list[File]] = (\\n store[\\\"filtered_files\\\"]\\n )\\n all_labels: dict[str, Label] = store[\\\"possible_labels\\\"]\\n labels: set[Label] = set()\\n comments: list[str] = []\\n errors: dict[os.PathLike, list[str]] = {}\\n\\n forecast_folder_name = store[\\\"FORECAST_FOLDER_NAME\\\"]\\n logger.info(\\n f\\\"Checking if the PR is updating outside the {forecast_folder_name}/ folder...\\\"\\n )\\n if (\\n PullRequestFileType.OTHER_NONFS in filtered_files or\\n PullRequestFileType.OTHER_FS in filtered_files\\n ):\\n logger.info((\\n \\\"⚠️ PR contains file changes that are not part of a valid \\\"\\n \\\"forecast submission (misnamed/misplaced forecast CSV, \\\"\\n \\\"non CSV files, etc.)\\\"\\n ))\\n comments.append(\\n \\\"⚠️ PR contains file changes that are not part of a valid \\\"\\n \\\"forecast submission (misnamed/misplaced forecast CSV, \\\"\\n \\\"non CSV files, etc.)\\\"\\n )\\n labels.add(all_labels[\\\"other-files-updated\\\"])\\n\\n if (\\n PullRequestFileType.MODEL_OTHER_FS in filtered_files \\n ):\\n success = False\\n logger.info((\\n \\\"❌ PR contains files submitted in the model folder that are not part of a valid \\\"\\n \\\"forecast submission\\\"\\n ))\\n comments.append(\\n \\\"❌ PR contains files submitted in the model folder that are not part of a valid \\\"\\n \\\"forecast submission\\\"\\n )\\n \\n else:\\n logger.info((\\n \\\"✔️ PR does not contain file changes that are not part of a \\\"\\n \\\"valid forecast submission (misnamed/misplaced forecast CSV, \\\"\\n \\\"non CSV files, etc.)\\\"\\n ))\\n\\n logger.info(\\\"Checking if the PR contains misplaced CSVs...\\\")\\n submission_formatting_instruction = store[\\\"SUBMISSION_FORMATTING_INSTRUCTION\\\"]\\n\\n if (PullRequestFileType.FORECAST not in filtered_files and\\n PullRequestFileType.OTHER_FS in filtered_files):\\n success = False\\n logger.info(\\\"❌ PR contains misplaced CSVs.\\\")\\n for github_file in filtered_files[PullRequestFileType.OTHER_FS]:\\n path = pathlib.Path(github_file.filename)\\n errors[path] = [(\\n \\\"The forecast CSV or metadata file is located in an \\\"\\n \\\"incorrect location and/or is misnamed (see \\\"\\n f\\\"[here]({submission_formatting_instruction})\\\"\\n \\\" for submission instructions. Please correct the errors \\\"\\n \\\"accordingly.\\\\n\\\"\\n \\\"We will still check any misplaced CSV(s) for \\\"\\n \\\"you, so that you can be sure that the CSVs are correct, \\\"\\n \\\"or correct any actual file content validation errors if \\\"\\n \\\"not.\\\"\\n )]\\n else:\\n logger.info(\\\"✔️ PR does not contain misplaced forecasts\\\")\\n\\n logger.info(\\\"Checking if the PR contains metadata updates...\\\")\\n if PullRequestFileType.METADATA in filtered_files:\\n logger.info(\\\"💡 PR contains metadata updates\\\")\\n comments.append(\\\"💡 PR contains metadata file changes.\\\")\\n labels.add(all_labels[\\\"metadata-change\\\"])\\n\\n return ValidationStepResult(\\n success=success,\\n labels=labels,\\n comments=comments,\\n file_errors=errors\\n )\",\n \"def log_diff(template_index, exists_in_source, source_row, exists_in_dest,\\n dest_row):\\n\\n template = nori.core.cfg['templates'][template_index]\\n\\n if nori.core.cfg['report_order'] == 'template':\\n if template_index not in diff_dict:\\n diff_dict[template_index] = []\\n diff_dict[template_index].append((exists_in_source, source_row,\\n exists_in_dest, dest_row, None))\\n diff_k = template_index\\n diff_i = len(diff_dict[template_index]) - 1\\n elif nori.core.cfg['report_order'] == 'keys':\\n keys_str = ()\\n if source_row is not None:\\n num_keys = source_row[0]\\n source_data = source_row[1]\\n keys_tuple = source_data[0:num_keys]\\n elif dest_row is not None:\\n num_keys = dest_row[0]\\n dest_data = dest_row[1]\\n keys_tuple = dest_data[0:num_keys]\\n if keys_tuple not in diff_dict:\\n diff_dict[keys_tuple] = []\\n diff_dict[keys_tuple].append((template_index, exists_in_source,\\n source_row, exists_in_dest, dest_row,\\n None))\\n diff_k = keys_tuple\\n diff_i = len(diff_dict[keys_tuple]) - 1\\n\\n if exists_in_source:\\n source_str = nori.pps(source_row[1])\\n elif exists_in_source is None:\\n source_str = '[no value match in source database]'\\n else:\\n source_str = '[no key match in source database]'\\n if exists_in_dest:\\n dest_str = nori.pps(dest_row[1])\\n elif exists_in_dest is None:\\n dest_str = '[no value match in destination database]'\\n else:\\n dest_str = '[no key match in destination database]'\\n\\n nori.core.status_logger.info(\\n 'Diff found for template {0} ({1}):\\\\nS: {2}\\\\nD: {3}' .\\n format(template_index, nori.pps(template[T_NAME_KEY]),\\n source_str, dest_str)\\n )\\n return (diff_k, diff_i)\",\n \"def analyze_frame(idx,true_frame, pred_frame):\\n global total_act\\n global total_correct\\n global acts \\n global k \\n global slots\\n global wrong_act_wrong_slot\\n global right_act_wrong_slot\\n global right_act_right_slot\\n global wrong_act_right_slot\\n # Compare Dialog Actss\\n flag = 0 \\n true_act = true_frame['act'] if 'act' in true_frame else None\\n pred_act = pred_frame['act'] if 'act' in pred_frame else None\\n\\n true_act_split = true_act.split(\\\":\\\")\\n true_act_simple = true_act_split[1] \\n true_act_detail = ':'.join(true_act_split[2:])\\n\\n if pred_act is None : \\n wrong_act_wrong_slot.add(idx)\\n return None \\n pred_act_split = pred_act.split(\\\":\\\")\\n if pred_act != \\\"ERR:CHITCHAT\\\" and pred_act != \\\"ERR:MISSING_CONTEXT\\\" and len(pred_act_split) < 3 : \\n wrong_act_wrong_slot.add(idx)\\n return None \\n pred_act_simple = pred_act_split[1] \\n pred_act_detail = ':'.join(pred_act_split[2:])\\n #ipdb.set_trace(context=20) \\n if true_act_simple in acts : \\n acts[true_act_simple]['total'] = acts[true_act_simple]['total'] + 1\\n if true_act_detail in acts[true_act_simple]['detail'] : ## already exists\\n acts[true_act_simple]['detail'][true_act_detail]['total'] += 1\\n else : \\n if not acts[true_act_simple]['detail'].get(true_act_detail) : \\n acts[true_act_simple]['detail'][true_act_detail] = {\\n 'total' : 1,\\n 'correct' : 0,\\n 'all-wrong' : {\\n\\n },\\n 'part-wrong' : {\\n\\n } \\n }\\n else :\\n acts[true_act_simple] = {\\n 'total' : 1,\\n 'correct' : 0,\\n 'detail' : {\\n\\n }\\n }\\n acts[true_act_simple]['detail'][true_act_detail] = {\\n 'total' : 1,\\n 'correct' : 0,\\n 'all-wrong' : {\\n\\n },\\n 'part-wrong' : {\\n\\n } \\n }\\n \\n if true_act == pred_act : ## Act correctly predicted \\n flag = 1\\n right_act_right_slot.add(idx)\\n total_correct = total_correct + 1\\n total_act = total_act + 1 \\n acts[true_act_simple]['correct'] += 1\\n if acts[true_act_simple]['detail'].get(true_act_detail) is None : \\n acts[true_act_simple]['detail'][true_act_detail]['correct'] = 1\\n else : \\n acts[true_act_simple]['detail'][true_act_detail]['correct'] = acts[true_act_simple]['detail'][true_act_detail]['correct'] + 1\\n else : \\n\\n total_act = total_act + 1 \\n #ipdb.set_trace(context=20) \\n if true_act_simple == pred_act_simple : ## Correct DA but wrong activities\\n if not acts[true_act_simple]['detail'].get(true_act_detail)['part-wrong'] : \\n acts[true_act_simple]['detail'].get(true_act_detail)['part-wrong'] = { \\n pred_act_detail : 1 \\n }\\n else :\\n if pred_act_detail in acts[true_act_simple]['detail'][true_act_detail]['part-wrong'] : \\n acts[true_act_simple]['detail'][true_act_detail]['part-wrong'][pred_act_detail] += 1\\n else : \\n acts[true_act_simple]['detail'][true_act_detail]['part-wrong'][pred_act_detail] = 1\\n\\n else : ## All wrong \\n if not acts[true_act_simple]['detail'].get(true_act_detail)['all-wrong'] : \\n acts[true_act_simple]['detail'].get(true_act_detail)['all-wrong'] = {\\n pred_act : 1 \\n }\\n else :\\n if pred_act in acts[true_act_simple]['detail'][true_act_detail]['all-wrong'] : \\n acts[true_act_simple]['detail'][true_act_detail]['all-wrong'][pred_act] += 1\\n else :\\n acts[true_act_simple]['detail'][true_act_detail]['all-wrong'][pred_act] = 1\\n \\n\\n\\n # Compare Slots\\n true_frame_slot_values = {f'{k}={v}' for k, v in true_frame.get('slots', [])}\\n pred_frame_slot_values = {f'{k}={v}' for k, v in pred_frame.get('slots', [])}\\n \\n if flag == 1 : ## if right DA, check slots \\n if true_frame_slot_values == pred_frame_slot_values : ## perfect prediction made \\n right_act_right_slot.add(idx)\\n else : \\n right_act_wrong_slot.add(idx)\\n else :\\n if true_frame_slot_values == pred_frame_slot_values : \\n wrong_act_right_slot.add(idx)\\n else :\\n wrong_act_wrong_slot.add(idx)\",\n \"def test_unchanged_status_text(self):\\n scale = \\\"count\\\"\\n metric1 = dict(type=\\\"metric_type\\\",\\n name=\\\"Metric\\\",\\n unit=\\\"units\\\",\\n scale=scale,\\n recent_measurements=[dict(count=dict(value=0,\\n status=\\\"near_target_met\\\")),\\n dict(count=dict(value=42,\\n status=\\\"near_target_met\\\"))])\\n metric2 = dict(type=\\\"metric_type\\\",\\n name=\\\"Metric\\\",\\n unit=\\\"units\\\",\\n scale=scale,\\n recent_measurements=[dict(count=dict(value=5,\\n status=\\\"target_met\\\")),\\n dict(count=dict(value=10,\\n status=\\\"target_not_met\\\"))])\\n metric_notification_data1 = MetricNotificationData(metric1, self.data_model, \\\"status_long_unchanged\\\")\\n metric_notification_data2 = MetricNotificationData(metric2, self.data_model, \\\"status_long_unchanged\\\")\\n notification = Notification(self.report, [metric_notification_data1,\\n metric_notification_data2], \\\"destination_uuid\\\", {})\\n text = build_notification_text(notification)\\n self.assertEqual(\\n \\\"[Report 1](https://report1) has 2 metrics that are notable:\\\\n\\\\n\\\"\\n \\\"* Metric has been yellow (near target met) for three weeks. Value: 42 units.\\\\n\\\"\\n \\\"* Metric has been red (target not met) for three weeks. Value: 10 units.\\\\n\\\",\\n text)\",\n \"def preprocess_one(workcalc):\\n \\n workcalc_name = workcalc.get_attrs()['_process_label']\\n version_preproc_dict = workchain_preproc_and_viewer_info[workcalc_name]\\n \\n prefix = None\\n reason = None\\n \\n for prefix_version in version_preproc_dict:\\n n_calls = version_preproc_dict[prefix_version]['n_calls']\\n retr_list_per_step = version_preproc_dict[prefix_version]['retrieved_files']\\n \\n # ---\\n # check if number of calls matches\\n if len(workcalc.get_outputs()) < n_calls:\\n if reason is None:\\n reason = \\\"Not all calculations started.\\\"\\n continue\\n \\n # ---\\n # check if all specified files are retrieved\\n success = True\\n for rlps in retr_list_per_step:\\n calc_step, retr_list = rlps\\n calc = workcalc.get_outputs()[calc_step]\\n retrieved_files = calc.out.retrieved.get_folder_list()\\n if not all(f in retrieved_files for f in retr_list):\\n if reason is None:\\n reason = \\\"Not all files were retrieved.\\\"\\n success = False\\n break\\n if not success:\\n continue\\n \\n # ---\\n # check if the required parameter is there\\n if 'req_param' in version_preproc_dict[prefix_version]:\\n req_param, req_key = version_preproc_dict[prefix_version]['req_param']\\n inp_dict = workcalc.get_inputs_dict()\\n if not (req_param in inp_dict and req_key in inp_dict[req_param].dict):\\n if reason is None:\\n reason = \\\"Required parameter not existing.\\\"\\n continue\\n \\n # ---\\n # found match! \\n prefix = prefix_version\\n break\\n \\n if prefix is None:\\n raise(Exception(reason))\\n \\n structure = workcalc.get_inputs_dict()[version_preproc_dict[prefix]['struct_label']]\\n pk_numbers = [e for e in structure.get_extras() if e.startswith(prefix[:-1])]\\n pk_numbers = [int(e.split('_')[1]) for e in pk_numbers if e.split('_')[1].isdigit()]\\n pks = [e[1] for e in structure.get_extras().items() if e[0].startswith(prefix[:-1])]\\n if workcalc.pk in pks:\\n return\\n nr = 1\\n if len(pk_numbers) != 0:\\n for nr in range(1, 100):\\n if nr in pk_numbers:\\n continue\\n break\\n structure.set_extra('%s_%d_pk'% (prefix, nr), workcalc.pk)\",\n \"def lf_abnormal_interp_with_spikes(report):\\n if 'interpretation' in report.sections.keys():\\n interpretation = report.sections['interpretation']\\n interp_text = interpretation['text']\\n return abnormal_interp_with_spikes(interp_text)\\n elif 'summary' in report.sections:\\n return abnormal_interp_with_spikes(report.sections['summary']['text'])\\n elif 'findings' in report.sections: # fall back to look in the findings \\n if 'summary' in report.sections['findings']: # fall back to look for a summary instead\\n return abnormal_interp_with_spikes(report.sections['findings']['summary'])\\n if 'impression' in report.sections['findings']:\\n return abnormal_interp_with_spikes(report.sections['findings']['impression'])\\n return ABSTAIN_VAL\\n elif 'narrative' in report.sections: # fall back to look in the findings \\n ky = 'narrative'\\n if 'summary' in report.sections[ky]: # fall back to look for a summary instead\\n return abnormal_interp_with_spikes(report.sections[ky]['summary'])\\n if 'impression' in report.sections[ky]:\\n return abnormal_interp_with_spikes(report.sections[ky]['impression'])\\n # could try running on all of findings but would really need to check then\\n \\n return ABSTAIN_VAL \\n else:\\n return ABSTAIN_VAL\",\n \"def rel_errors(self):\\n ped_entries = {m[\\\"patient\\\"]: m for m in self.pedigree}\\n result = {}\\n import_job = ImportVariantsBgJob.objects.filter(case_name=self.name).order_by(\\n \\\"-date_created\\\"\\n )\\n if import_job and not import_job[0].bg_job.status == \\\"done\\\":\\n return result\\n\\n try:\\n variant_set = self.latest_variant_set\\n if variant_set:\\n for rel_stats in variant_set.variant_stats.relatedness.all():\\n relationship = \\\"other\\\"\\n if (\\n ped_entries[rel_stats.sample1][\\\"father\\\"]\\n == ped_entries[rel_stats.sample2][\\\"father\\\"]\\n and ped_entries[rel_stats.sample1][\\\"mother\\\"]\\n == ped_entries[rel_stats.sample2][\\\"mother\\\"]\\n and ped_entries[rel_stats.sample1][\\\"father\\\"] != \\\"0\\\"\\n and ped_entries[rel_stats.sample1][\\\"mother\\\"] != \\\"0\\\"\\n ):\\n relationship = \\\"sibling-sibling\\\"\\n elif (\\n ped_entries[rel_stats.sample1][\\\"father\\\"] == rel_stats.sample2\\n or ped_entries[rel_stats.sample1][\\\"mother\\\"] == rel_stats.sample2\\n or ped_entries[rel_stats.sample2][\\\"father\\\"] == rel_stats.sample1\\n or ped_entries[rel_stats.sample2][\\\"mother\\\"] == rel_stats.sample1\\n ):\\n relationship = \\\"parent-child\\\"\\n if (\\n relationship == \\\"sibling-sibling\\\"\\n and rel_stats.relatedness() < THRESH_SIBLING\\n ) or (\\n relationship == \\\"parent-child\\\" and rel_stats.relatedness() < THRESH_PARENT\\n ):\\n for sample in (rel_stats.sample1, rel_stats.sample2):\\n result.setdefault(sample, []).append(\\n (\\n \\\"pedigree shows {} relation for {} and {} but variants show low degree \\\"\\n \\\"of relatedness\\\"\\n ).format(\\n relationship,\\n only_source_name(rel_stats.sample1),\\n only_source_name(rel_stats.sample2),\\n )\\n )\\n return result\\n except SmallVariantSet.variant_stats.RelatedObjectDoesNotExist:\\n return {}\",\n \"def diff_it(self):\\n data = {}\\n differ = difflib.Differ()\\n first = self.first.data.keys()\\n first.sort()\\n second = self.second.data.keys()\\n second.sort()\\n # Save data differently if file was measured only in first, only\\n # in second or in both reports\\n for item in differ.compare(first, second):\\n fil = item[2:]\\n mode = item[:1]\\n if mode == ' ':\\n data[fil] = [self.first.data[fil], self.second.data[fil]]\\n elif mode == '+':\\n data[fil] = [None, self.second.data[fil]]\\n elif mode == '-':\\n data[fil] = [self.first.data[fil], None]\\n return collections.OrderedDict(sorted(data.items()))\",\n \"def _consist_numeric(col, _df1, _df2, _key1, _key2, img_dir, date_flag=False):\\n\\n df1, df2 = _df1.copy(), _df2.copy()\\n df = pd.merge(df1, df2, left_on=_key1, right_on=_key2, how=\\\"inner\\\")\\n\\n if (df['%s_x' %(col)].dropna().shape[0] == 0) or (df['%s_y' %(col)].dropna().shape[0] == 0):\\n if (df['%s_x' %(col)].dropna().shape[0] == 0) and (df['%s_y' %(col)].dropna().shape[0] == 0):\\n error_msg = 'all nan in both table'\\n elif df['%s_x' %(col)].dropna().shape[0] == 0:\\n error_msg = 'all nan in table1'\\n else:\\n error_msg = 'all nan in table2'\\n return {'column': col, 'error_msg': error_msg}\\n\\n df = df.dropna(how='any', subset=['%s_x' % (col), '%s_y' % (col)]).reset_index(drop=True)\\n df['diff_temp'] = df['%s_y' %(col)] - df['%s_x' %(col)]\\n corr = round(spearmanr(df['%s_x' %(col)].values, df['%s_y' %(col)].values)[0], 3)\\n\\n output = [\\n {'feature': 'column', 'value': col, 'graph': 'consistency check'},\\n {'feature': 'corr', 'value': corr},\\n {'feature': 'min diff', 'value': round(df['diff_temp'].min(), 3)},\\n {'feature': 'mean diff', 'value': round(df['diff_temp'].mean(), 3)},\\n {'feature': 'median diff', 'value': round(df['diff_temp'].median(), 3)},\\n {'feature': 'max diff', 'value': round(df['diff_temp'].max(), 3)},\\n ]\\n\\n draw_values = df['diff_temp'].dropna().values\\n origin_value_4 = [np.min(draw_values), np.mean(draw_values), np.median(draw_values), np.max(draw_values)]\\n\\n # get distribution\\n scale_flg = 0\\n draw_value_4 = origin_value_4\\n if np.max([abs(origin_value_4[0]), abs(origin_value_4[3])]) >= pow(10, 6):\\n scale_flg = 1\\n draw_values, draw_value_4 = _get_scale_draw_values(draw_values, draw_value_4)\\n\\n # draw the scatter plot\\n both_min = np.min([df['%s_x' %(col)].min(), df['%s_y' %(col)].min()])\\n both_max = np.max([df['%s_x' %(col)].max(), df['%s_y' %(col)].max()])\\n\\n dpi = 72\\n plt.figure(figsize=(635. / dpi, 635. / (9. / 4.) / dpi), dpi=dpi)\\n plt.subplot(121)\\n plt.title('Scatter plot for values')\\n plt.scatter(df['%s_x' %(col)].values, df['%s_y' %(col)].values, c=TABLE1_DARK, s=5)\\n plt.plot([both_min, both_max], [both_min, both_max], '--', c='#bbbbbb')\\n\\n plt.xlim(both_min, both_max)\\n plt.ylim(both_min, both_max)\\n\\n ax2 = plt.subplot(122)\\n if len(np.unique(draw_values)) <= 10:\\n sns.countplot(draw_values, palette=sns.color_palette([TABLE2_DARK]))\\n if len(np.unique(draw_values)) > 5:\\n plt.xticks(rotation=90)\\n else:\\n sns.distplot(draw_values, color=TABLE2_DARK)\\n y_low, y_up = ax2.get_ylim()\\n _draw_texts(text_values=origin_value_4, draw_value_4=draw_value_4, mark=1, y_low=y_low, y_up=y_up)\\n\\n if date_flag:\\n plt.title('Distribution of differences (in months)')\\n elif scale_flg:\\n plt.title('Distribution of differences (log10 scale)')\\n else:\\n plt.title('Distribution of differences')\\n\\n # save the graphs\\n # adjust graph name\\n graph_name = col\\n if '/' in graph_name:\\n graph_name = graph_name.replace('/', '')\\n plt.savefig(os.path.join(img_dir, graph_name + '.png'), transparent=True, dpi=dpi)\\n return {'column': col, 'result_df': pd.DataFrame(output), 'corr': {'column': col, 'corr': corr}}\",\n \"def compute_advice(self):\\n for advice in self:\\n old_lines = self.env['hr.payroll.advice.line'].search([('advice_id', '=', advice.id)])\\n if old_lines:\\n old_lines.unlink()\\n payslips = self.env['hr.payslip'].search([('date_from', '<=', advice.date), ('date_to', '>=', advice.date), ('state', '=', 'done')])\\n for slip in payslips:\\n if not slip.sudo().employee_id.bank_account_id and not slip.sudo().employee_id.bank_account_id.acc_number:\\n raise UserError(_('Please define bank account for the %s employee') % (slip.employee_id.name,))\\n payslip_line = self.env['hr.payslip.line'].search([('slip_id', '=', slip.id), ('code', '=', 'NET')], limit=1)\\n if payslip_line:\\n self.env['hr.payroll.advice.line'].create({\\n 'advice_id': advice.id,\\n 'name': slip.sudo().employee_id.bank_account_id.acc_number,\\n 'ifsc_code': slip.sudo().employee_id.bank_account_id.bank_bic or '',\\n 'employee_id': slip.employee_id.id,\\n 'bysal': payslip_line.total\\n })\\n slip.advice_id = advice.id\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5009308","0.50050104","0.47927547","0.47090858","0.4646092","0.46367276","0.4600246","0.45939845","0.4547362","0.45332745","0.45131713","0.45066488","0.44925582","0.44843617","0.44840214","0.4477567","0.4472213","0.44629148","0.4452782","0.4435036","0.44328246","0.44308645","0.44265833","0.4421612","0.44146124","0.4413403","0.4410658","0.44066277","0.4400675","0.43965662","0.43781736","0.43699896","0.43698013","0.43590617","0.43502194","0.4350029","0.43460575","0.43427908","0.4332767","0.4331764","0.43228325","0.4321928","0.43122923","0.43089813","0.43023753","0.4300798","0.43000132","0.4298905","0.42902955","0.42810413","0.4279823","0.42770475","0.42768544","0.4275416","0.4269213","0.42691246","0.42684186","0.42681015","0.4267813","0.4267813","0.42658833","0.42568272","0.4253994","0.4251924","0.42514658","0.42436707","0.42415765","0.42327845","0.42259216","0.42256454","0.42240167","0.42184362","0.42133504","0.42113551","0.42102885","0.4208856","0.41949108","0.41949108","0.41930157","0.41922373","0.41910413","0.41871935","0.41834024","0.41822806","0.4178193","0.4178075","0.41760555","0.41748223","0.41744244","0.4172829","0.41689974","0.41668284","0.41653827","0.41613853","0.4157697","0.41568294","0.41426092","0.41405603","0.41349748","0.4133247"],"string":"[\n \"0.5009308\",\n \"0.50050104\",\n \"0.47927547\",\n \"0.47090858\",\n \"0.4646092\",\n \"0.46367276\",\n \"0.4600246\",\n \"0.45939845\",\n \"0.4547362\",\n \"0.45332745\",\n \"0.45131713\",\n \"0.45066488\",\n \"0.44925582\",\n \"0.44843617\",\n \"0.44840214\",\n \"0.4477567\",\n \"0.4472213\",\n \"0.44629148\",\n \"0.4452782\",\n \"0.4435036\",\n \"0.44328246\",\n \"0.44308645\",\n \"0.44265833\",\n \"0.4421612\",\n \"0.44146124\",\n \"0.4413403\",\n \"0.4410658\",\n \"0.44066277\",\n \"0.4400675\",\n \"0.43965662\",\n \"0.43781736\",\n \"0.43699896\",\n \"0.43698013\",\n \"0.43590617\",\n \"0.43502194\",\n \"0.4350029\",\n \"0.43460575\",\n \"0.43427908\",\n \"0.4332767\",\n \"0.4331764\",\n \"0.43228325\",\n \"0.4321928\",\n \"0.43122923\",\n \"0.43089813\",\n \"0.43023753\",\n \"0.4300798\",\n \"0.43000132\",\n \"0.4298905\",\n \"0.42902955\",\n \"0.42810413\",\n \"0.4279823\",\n \"0.42770475\",\n \"0.42768544\",\n \"0.4275416\",\n \"0.4269213\",\n \"0.42691246\",\n \"0.42684186\",\n \"0.42681015\",\n \"0.4267813\",\n \"0.4267813\",\n \"0.42658833\",\n \"0.42568272\",\n \"0.4253994\",\n \"0.4251924\",\n \"0.42514658\",\n \"0.42436707\",\n \"0.42415765\",\n \"0.42327845\",\n \"0.42259216\",\n \"0.42256454\",\n \"0.42240167\",\n \"0.42184362\",\n \"0.42133504\",\n \"0.42113551\",\n \"0.42102885\",\n \"0.4208856\",\n \"0.41949108\",\n \"0.41949108\",\n \"0.41930157\",\n \"0.41922373\",\n \"0.41910413\",\n \"0.41871935\",\n \"0.41834024\",\n \"0.41822806\",\n \"0.4178193\",\n \"0.4178075\",\n \"0.41760555\",\n \"0.41748223\",\n \"0.41744244\",\n \"0.4172829\",\n \"0.41689974\",\n \"0.41668284\",\n \"0.41653827\",\n \"0.41613853\",\n \"0.4157697\",\n \"0.41568294\",\n \"0.41426092\",\n \"0.41405603\",\n \"0.41349748\",\n \"0.4133247\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5701247"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":7380,"cells":{"query":{"kind":"string","value":"Create a Vocabulary object."},"document":{"kind":"string","value":"def __init__(self, max_size=None, lower=True, unk_token=True, remove_stopwords=False, specials=('<pad>',)):\n self._max_size = max_size\n self._lower = lower\n self._unk = unk_token\n self.token2id = {token: i for i, token in enumerate(specials)}\n self._id2token = list(specials)\n self._token_count = Counter()\n self.can_remove_stopwords=remove_stopwords\n self.num_docs = 0\n self.num_pos = 0\n self.num_nnz = 0\n self.corpus=None"},"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 vocab():\n symbols = DEFAULT_SPECIAL_SYMBOLS + [\"mouse\", \"dog\", \"tree\"]\n return Vocabulary(symbols)","def from_dict(cls, dikt: dict) -> 'Vocabulary':\n return util.deserialize_model(dikt, cls)","def create_vocab(vocab_path='ORBvoc-synth.txt'):\n total_time = 10 # seconds\n num_frames = 20\n speed = 3.0\n vocab_builder = VocabularyBuilder()\n for seed in tqdm(range(100), total=100):\n image_builder = DemoImageBuilder(\n mode=ImageMode.MONOCULAR, seed=seed,\n length=total_time * speed\n )\n for idx in range(num_frames):\n time = total_time * idx / num_frames\n image = image_builder.create_frame(time)\n vocab_builder.add_image(image.pixels)\n vocab_builder.build_vocabulary(str(vocab_path))","def create(self, vocabulary=list) -> dict:\n try:\n out = {}\n for i in range(len(vocabulary)):\n out[vocabulary[i]] = i\n return(out)\n except Exception as error:\n print(f\"Error: self.create([...]) -> {error}\")","def create_vocab(\n self,\n instance_datasets: Iterable[InstanceDataset],\n config: Optional[VocabularyConfiguration] = None,\n ) -> Vocabulary:\n # The transformers feature comes with its own vocab, no need to create anything if it is the only feature\n if self.config.features.configured_namespaces == [\n TransformersFeatures.namespace\n ]:\n return self.vocab\n\n self._check_for_word_vector_weights_file()\n\n config = config or VocabularyConfiguration()\n\n vocab = Vocabulary.from_instances(\n instances=(\n instance for dataset in instance_datasets for instance in dataset\n ),\n max_vocab_size=config.max_vocab_size,\n min_count=config.min_count,\n pretrained_files=config.pretrained_files,\n only_include_pretrained_words=config.only_include_pretrained_words,\n min_pretrained_embeddings=config.min_pretrained_embeddings,\n tokens_to_add=config.tokens_to_add,\n )\n\n # If the vocab is the same, this is just a no-op\n self._model.extend_vocabulary(vocab)\n\n return vocab","def create_vocabulary(vocabulary_path, json_vocab_path):\n if not gfile.Exists(vocabulary_path):\n print(\"Transform vocabulary to %s\" % vocabulary_path)\n with gfile.GFile(json_vocab_path, mode=\"rb\") as f:\n jvocab = json.load(f)\n vocab = jvocab['w2id']\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get)\n with gfile.GFile(vocabulary_path, mode=\"wb\") as vocab_file:\n for w in vocab_list:\n vocab_file.write(w + b\"\\n\")","def make_vocab(corpus_dictionary, vocab_path):\n with open(vocab_path, 'wb') as fout:\n pickle.dump(corpus_dictionary, fout)\n print('Saved dictionary to', vocab_path)","def load(cls, path: str) -> 'Vocab':\n with open(path, 'r', encoding='utf-8') as f:\n return cls.from_json(f.read())","def vocabulary(self, config=Config()):\n raise NotImplementedError(\"Class %s doesn't implement vocabulary()\" % self.__class__.__name__)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"rb\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"r\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if os.path.exists(vocabulary_path):\n rev_vocab = []\n with codecs_open(vocabulary_path, \"rb\", encoding=\"utf-8\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"rb\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [tf.compat.as_bytes(line.strip()) for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"rb\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"rb\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"r\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def __init__(self, vocabulary_size=1000):\n self.vocabulary_size = vocabulary_size","def create_vocabulary(sentences, path):\n print('creating vocab..')\n\n word_dict = dict(); vocabulary = dict()\n for sentence in sentences:\n for word in nltk.word_tokenize(sentence):\n if word not in word_dict:\n word_dict[word] = ''\n word_dict['<s>'] = ''\n word_dict['</s>'] = ''\n\n with open(path, encoding=\"utf8\") as f:\n for line in f:\n word, vec = line.split(' ', 1)\n if word in word_dict:\n vocabulary[word] = np.fromstring(vec, sep=' ')\n\n print('vocabulary was created successfully!')\n return vocabulary","def _create_vocab(captions):\n print(\"Creating vocabulary.\")\n min_word_count = 4\n word_counts_output_file = '/Users/lzg/Desktop/image_caption/word_count.txt'\n counter = Counter()\n for c in captions:\n counter.update(c)\n print(\"Total words:\", len(counter))\n\n # Filter uncommon words and sort by descending count.\n word_counts = [x for x in counter.items() if x[1] >= min_word_count]\n word_counts.sort(key=lambda x: x[1], reverse=True)\n print(\"Words in vocabulary:\", len(word_counts))\n\n # Write out the word counts file.\n with tf.gfile.FastGFile(word_counts_output_file, \"w\") as f:\n f.write(\"\\n\".join([\"%s %d\" % (w, c) for w, c in word_counts]))\n print(\"Wrote vocabulary file:\", word_counts_output_file)\n\n # Create the vocabulary dictionary.\n reverse_vocab = [x[0] for x in word_counts]\n unk_id = len(reverse_vocab)\n vocab_dict = dict([(x, y) for (y, x) in enumerate(reverse_vocab)])\n # vocab = Vocabulary(vocab_dict, unk_id)\n\n return vocab_dict, unk_id","def getVocabulary(self): # real signature unknown; restored from __doc__\n pass","def load(cls, w2v_vocab):\n n2v_vocab = cls()\n for key, value in w2v_vocab.__dict__.items():\n setattr(n2v_vocab, key, value)\n return n2v_vocab","def getVocabulary(vocabulary_id):\n relex_web = getSite().restrictedTraverse('relex_web')\n key = KEY_STORAGE + \".\" + vocabulary_id\n vocabulary = json.loads(getattr(relex_web, key, \"[]\"))\n return vocabulary","def from_list(texts, max_size=None, min_freq=None, tokenizer=None):\n \n if tokenizer is None:\n tokenizer = Preprocess([\n Consecutive(),\n RemoveEmoji(),\n WordTokenizer()\n ])\n\n vocab = Vocabulary(\n max_size=max_size,\n min_freq=min_freq)\n\n token_lst = tokenizer(texts)\n vocab.build_vocab(token_lst)\n\n return vocab","def create_vocab(input_iter, min_frequency):\n vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor(\n FLAGS.max_sentence_len,\n min_frequency=min_frequency,\n tokenizer_fn=tokenizer_fn)\n\n vocab_processor.fit(input_iter)\n return vocab_processor","def create_vocabulary(vocabulary_path, data_paths, max_vocabulary_size,\n tokenizer=None, normalize_digits=True):\n if not gfile.Exists(vocabulary_path):\n vocab = {}\n files = []\n files += [data_paths+f for f in os.listdir(data_paths) ]\n for one_file in files:\n with gfile.GFile(one_file, mode=\"rb\") as f:\n review = f.read()\n tokens = tokenizer(review) if tokenizer else character_tokenizer(review)\n for w in tqdm(tokens):\n word = _DIGIT_RE.sub(b\"0\", w) if normalize_digits else w\n if word in vocab:\n vocab[word] += 1\n else:\n vocab[word] = 1\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\n if len(vocab_list) > max_vocabulary_size:\n vocab_list = vocab_list[:max_vocabulary_size]\n with gfile.GFile(vocabulary_path, mode=\"wb\") as vocab_file:\n for w in vocab_list:\n vocab_file.write(w + b\"\\n\")\n else:\n print(\"Vocabulary already created.\")","def _load_vocab(vocab_file_name, language):\n vocab = []\n vocab_size = 0\n #with codecs.getreader(\"utf-8\")(tf.gfile.GFile(vocab_file_name), \"rb\") as f:\n with tf.gfile.GFile(vocab_file_name) as f:\n for word in f:\n vocab.append(word.strip())\n vocab_size += 1\n\n if not EOS in vocab:\n vocab = [EOS] + vocab\n if not SOS in vocab:\n vocab = [SOS] + vocab\n if not UNK in vocab:\n vocab = [UNK] + vocab\n\n reverse_dictionary = {}\n new_vocab_file_name = vocab_file_name + \".new\"\n with tf.gfile.GFile(new_vocab_file_name, \"wb\") as f:\n reverse_dictionary = {}\n i = 0\n for word in vocab:\n f.write(\"%s\\n\" % word)\n reverse_dictionary.update({i : word})\n i+=1\n\n vocab_table = tf.contrib.lookup.index_table_from_file(new_vocab_file_name, default_value = 0)\n\n eos_id_tensor = tf.cast(vocab_table.lookup(tf.constant(EOS)), tf.int32)\n sos_id_tensor = tf.cast(vocab_table.lookup(tf.constant(SOS)), tf.int32)\n\n return Vocab(lang=language,\n table=vocab_table,\n size=vocab_size,\n reverse_dict=reverse_dictionary,\n sos_id_tensor=sos_id_tensor,\n eos_id_tensor=eos_id_tensor)","def load_vocab(fn):\n return corpora.Dictionary.load(fn)","def create_vocabulary(vocabulary_path, data_path, max_vocabulary_size,\n tokenizer=None, normalize_digits=True):\n if not gfile.Exists(vocabulary_path):\n print(\"Creating vocabulary %s from data %s\" % (vocabulary_path, data_path))\n vocab = {}\n with gfile.GFile(data_path, mode=\"rb\") as f:\n counter = 0\n for line in f:\n counter += 1\n if counter % 100000 == 0:\n print(\" processing line %d\" % counter)\n tokens = tokenizer(line) if tokenizer else basic_tokenizer(line)\n for w in tokens:\n word = re.sub(_DIGIT_RE, b\"0\", w) if normalize_digits else w\n if word in vocab:\n vocab[word] += 1\n else:\n vocab[word] = 1\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\n if len(vocab_list) > max_vocabulary_size:\n print(\"vocab too big\")\n vocab_list = vocab_list[:max_vocabulary_size]\n with gfile.GFile(vocabulary_path, mode=\"wb\") as vocab_file:\n for w in vocab_list:\n vocab_file.write(w + b\"\\n\")","def deserialize(self, descriptor: Dict, data: List) -> ObjectHandle:\n return VocabularyHandle(\n values=set(data),\n name=descriptor['name'],\n namespace=descriptor['namespace'],\n label=descriptor.get('label'),\n description=descriptor.get('description')\n )","def create_vocabulary(vocabulary_path, data_path, max_vocabulary_size,\n tokenizer=None, normalize_digits=True,\n _DIGIT_RE=re.compile(br\"\\d\"),\n _START_VOCAB=[b\"_PAD\", b\"_GO\", b\"_EOS\", b\"_UNK\"]):\n if not gfile.Exists(vocabulary_path):\n print(\"Creating vocabulary %s from data %s\" % (vocabulary_path, data_path))\n vocab = {}\n with gfile.GFile(data_path, mode=\"rb\") as f:\n counter = 0\n for line in f:\n counter += 1\n if counter % 100000 == 0:\n print(\" processing line %d\" % counter)\n tokens = tokenizer(line) if tokenizer else basic_tokenizer(line)\n for w in tokens:\n word = re.sub(_DIGIT_RE, b\"0\", w) if normalize_digits else w\n if word in vocab:\n vocab[word] += 1\n else:\n vocab[word] = 1\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\n if len(vocab_list) > max_vocabulary_size:\n vocab_list = vocab_list[:max_vocabulary_size]\n with gfile.GFile(vocabulary_path, mode=\"wb\") as vocab_file:\n for w in vocab_list:\n vocab_file.write(w + b\"\\n\")\n else:\n print(\"Vocabulary %s from data %s exists\" % (vocabulary_path, data_path))","def create_restricted_vocabulary(field, options,\n message_factory=None,\n restricted=lambda x: True):\n class GeneratedVocabulary(object):\n\n @property\n def option_level_mapping(self):\n option_level_mapping = [list(a) for a in self.options[:]]\n option_level_mapping = dict([a for a in option_level_mapping\n if not a.reverse()])\n return option_level_mapping\n\n @property\n def option_names(self):\n return [a[1] for a in self.options]\n\n @property\n def options(self):\n if callable(self._options):\n return self._options()\n else:\n return self._options\n\n def __call__(self, context):\n self.context = context\n\n terms = []\n for name in self.get_allowed_option_names():\n title = name\n if message_factory:\n title = self._(name)\n terms.append(\n zope.schema.vocabulary.SimpleTerm(name, title=title))\n return zope.schema.vocabulary.SimpleVocabulary(terms)\n\n def get_allowed_option_names(self):\n acquisition_value = self._get_acquisiton_value()\n\n if not self.restricted():\n return self.option_names\n\n if not acquisition_value or acquisition_value not in self.option_names:\n return self.option_names\n\n allowed_option_names = []\n allowed_option_names.append(acquisition_value)\n allowed_level = self.option_level_mapping[acquisition_value] + 1\n for level, name in self.options:\n if level >= allowed_level:\n allowed_option_names.append(name)\n\n return allowed_option_names\n\n def _get_acquisiton_value(self):\n context = self.context\n if isinstance(context, MetadataBase) or context is None:\n # we do not test the factory, it is not acquisition wrapped and\n # we cant get the request...\n return None\n request = self.context.REQUEST\n # XXX CHANGED FROM PATH_TRANSLATED TO PATH_INFO\n # because the test don't work\n if '++add++' in request.get('PATH_INFO', ''):\n # object is not yet existing, context is container\n obj = context\n else:\n # object is existing, container is parent of context\n obj = context.aq_inner.aq_parent\n while not ISiteRoot.providedBy(obj):\n try:\n return self.field.get(obj)\n except AttributeError:\n try:\n interface_ = self.field.interface\n except AttributeError:\n pass\n else:\n try:\n adpt = interface_(obj)\n except TypeError:\n # could not adapt\n pass\n else:\n return self.field.get(adpt)\n obj = obj.aq_inner.aq_parent\n return self.field.default\n\n GeneratedVocabulary.field = field\n GeneratedVocabulary._options = options\n GeneratedVocabulary._ = message_factory\n GeneratedVocabulary.restricted = restricted\n\n return GeneratedVocabulary","def create_vocabulary(vocabulary_path, words, max_vocabulary_size, normalize_digits=True):\n if not gfile.Exists(vocabulary_path):\n print(\"Creating vocabulary %s with max size %d\" % (vocabulary_path, max_vocabulary_size))\n vocab = {}\n counter = 0\n for w in words:\n counter += 1\n if counter % 10000 == 0:\n print(\" processing word %d = %s\" % (counter, w))\n word = re.sub(_DIGIT_RE, \"0\", w) if normalize_digits else w\n if word in vocab:\n vocab[word] += 1\n else:\n vocab[word] = 1\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\n if len(vocab_list) > max_vocabulary_size:\n vocab_list = vocab_list[:max_vocabulary_size]\n with gfile.GFile(vocabulary_path, mode=\"w\") as vocab_file:\n for w in vocab_list:\n vocab_file.write(w + \"\\n\")","def initialize_vocabulary(vocabulary_path):\n characters_class = 9999\n\n if os.path.exists(vocabulary_path):\n with codecs.open(vocabulary_path, 'r', encoding='utf-8') as voc_file:\n rev_vocab = [line.strip() for line in voc_file]\n\n vocab = {x: y for (y, x) in enumerate(rev_vocab)}\n\n reserved_char_size = characters_class - len(rev_vocab)\n if reserved_char_size < 0:\n raise ValueError(\"Number of characters in vocabulary is equal or larger than config.characters_class\")\n\n for _ in range(reserved_char_size):\n rev_vocab.append('')\n\n # put space at the last position\n vocab[' '] = len(rev_vocab)\n rev_vocab.append(' ')\n return vocab, rev_vocab\n\n raise ValueError(\"Initializing vocabulary ends: %s\" % vocabulary_path)","def create_vocabulary(vocabulary_path, data_path, max_vocabulary_size,\n tokenizer=None, normalize_digits=True):\n if not gfile.Exists(vocabulary_path):\n print(\"Creating vocabulary %s from data %s\" % (vocabulary_path, data_path))\n vocab = {}\n with gfile.GFile(data_path, mode=\"r\") as f:\n counter = 0\n for line in f:\n counter += 1\n line = line.strip().split('\\t')[0]\n if counter % 100000 == 0:\n print(\" processing line %d\" % counter)\n tokens = tokenizer(line) if tokenizer else basic_tokenizer(line)\n for w in tokens:\n word = re.sub(_DIGIT_RE, \"0\", w) if normalize_digits else w\n if word in vocab:\n vocab[word] += 1\n else:\n vocab[word] = 1\n sorted_vocab = sorted(vocab, key=vocab.get, reverse=True)\n vocab_list = _START_VOCAB + sorted_vocab\n if len(vocab_list) > max_vocabulary_size:\n vocab_list = vocab_list[:max_vocabulary_size]\n print(\"Corpus %s has %d tokens, %d uniq words, %d vocab at cutoff %d.\" % (\n data_path, sum(vocab.values()), len(vocab), max_vocabulary_size, vocab[sorted_vocab[max_vocabulary_size - len(_START_VOCAB)]] ) )\n else:\n print(\"Corpus %s has %d tokens, %d uniq words, %d vocab at cutoff %d.\" % (\n data_path, sum(vocab.values()), len(vocab), len(vocab), 0))\n\n with gfile.GFile(vocabulary_path, mode=\"wb\") as vocab_file:\n for w in vocab_list:\n vocab_file.write(w + \"\\n\")","def build_vocab(self):\n if self.test_file is None:\n print('test_file is None')\n file_list = [self.train_file, self.dev_file]\n else:\n file_list = [self.train_file, self.dev_file, self.test_file]\n\n examples = []\n for file_name in file_list:\n examples += ParseExample.load_data(file_name)\n\n sents = []\n for example in examples:\n warrant0, warrant1, reason, claim, debate_meta_data, negclaim = example.get_six(type=WORD_TYPE)\n sents.append(warrant0)\n sents.append(warrant1)\n sents.append(reason)\n sents.append(claim)\n sents.append(debate_meta_data)\n\n vocab = data_utils.build_word_vocab(sents)\n\n return vocab","def from_pickle(pkl):\n assert os.path.exists(pkl), f\"{pkl} not exists\"\n with open(pkl, 'rb') as f:\n vocab = pickle.load(f)\n \n return vocab","def get_vocab(self):\n if os.path.exists(self.vocab_file) & self.vocab_from_file:\n f = open(self.vocab_file, \"rb\")\n vocab = pickle.load(f)\n self.word2idx = vocab.word2idx\n self.idx2word = vocab.idx2word\n f.close()\n else:\n self.build_vocab()\n with open(self.vocab_file, 'wb') as f:\n pickle.dump(self, f)","def __init__(self, file):\n with open(file, 'r') as f:\n self.vocab = json.loads(f.read())","def vocab(self) -> Vocabulary:\n return self._model.vocab","def initialize_vocabulary(self,vocabulary_path):\n if tf.gfile.Exists(vocabulary_path):\n vocab = corpora.Dictionary.load(vocabulary_path)\n print(\"vocab length: \",len(vocab.token2id))\n\n return vocab.token2id, vocab.token2id.keys()\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def create_vocab_table(db, vocab):\n con = lite.connect(db)\n with con:\n cur = con.cursor()\n cur.execute(\"CREATE TABLE IF NOT EXISTS Vocab(vocab TEXT)\")\n for i in range(0, len(vocab)):\n vocab[i] = (vocab[i],)\n with con:\n cur = con.cursor()\n cur.executemany(\"INSERT INTO Vocab VALUES (?)\", vocab)","def load_vocab(path: str) -> Vocab:\n return torch.load(path, map_location=lambda storage, loc: storage)['args'].vocab","def buildVocabulary(paragraphs, verbose=True):\n vocabulary = []\n \n for p in paragraphs:\n for word in p.split():\n vocabulary.append(word)\n\n vocabulary = set(vocabulary)\n if verbose:\n print('Built vocabulary of %d unique words'%len(vocabulary))\n \n return list(vocabulary)","def load_vocab(self, fn):\n vocab = load_vocab(fn)\n self.vocab = vocab\n self.has_vocab = True","def get_vocab(self):\n\n\t\tself.parse_transcript() \n\t\tself.purge_words()\n\t\tself.analyze_words()\n\t\tself.sort_word_analysis()","def _build_vocabulary(input_files):\n if FLAGS.vocab_file:\n tf.logging.info(\"Loading existing vocab file.\")\n vocab = collections.OrderedDict()\n with tf.gfile.GFile(FLAGS.vocab_file, mode=\"r\") as f:\n for i, line in enumerate(f):\n word = line.decode(\"utf-8\").strip()\n assert word not in vocab, \"Attempting to add word twice: %s\" % word\n vocab[word] = i\n tf.logging.info(\"Read vocab of size %d from %s\",\n len(vocab), FLAGS.vocab_file)\n return vocab\n\n tf.logging.info(\"Creating vocabulary.\")\n num = 0\n wordcount = collections.Counter()\n for input_file in input_files:\n tf.logging.info(\"Processing file: %s\", input_file)\n for sentence in tf.gfile.FastGFile(input_file):\n wordcount.update(sentence.split())\n\n num += 1\n if num % 1000000 == 0:\n tf.logging.info(\"Processed %d sentences\", num)\n\n tf.logging.info(\"Processed %d sentences total\", num)\n\n words = wordcount.keys()\n freqs = wordcount.values()\n sorted_indices = np.argsort(freqs)[::-1]\n\n vocab = collections.OrderedDict()\n vocab[special_words.EOS] = special_words.EOS_ID\n vocab[special_words.UNK] = special_words.UNK_ID\n for w_id, w_index in enumerate(sorted_indices[0:FLAGS.num_words - 2]):\n vocab[words[w_index]] = w_id + 2 # 0: EOS, 1: UNK.\n\n tf.logging.info(\"Created vocab with %d words\", len(vocab))\n\n vocab_file = os.path.join(FLAGS.output_dir, \"vocab.txt\")\n with tf.gfile.FastGFile(vocab_file, \"w\") as f:\n f.write(\"\\n\".join(vocab.keys()))\n tf.logging.info(\"Wrote vocab file to %s\", vocab_file)\n\n word_counts_file = os.path.join(FLAGS.output_dir, \"word_counts.txt\")\n with tf.gfile.FastGFile(word_counts_file, \"w\") as f:\n for i in sorted_indices:\n f.write(\"%s %d\\n\" % (words[i], freqs[i]))\n tf.logging.info(\"Wrote word counts file to %s\", word_counts_file)\n\n return vocab","def trackVocabulary(context):\n ct = getToolByName(context,'portal_catalog')\n tracks = ct.searchResults(portal_type='apyb.papers.track', sort_on='getObjPositionInParent')\n items = [SimpleTerm(b.UID,b.UID,b.Title) for b in tracks]\n return SimpleVocabulary(items)","def build_vocabulary(self):\n \n for iCount in range(0,len(self.documents)):\n for jCount in range(iCount,len(self.documents[iCount])):\n self.vocabulary.append(self.documents[iCount][jCount])\n\n self.vocabulary = set(self.vocabulary)\n\t\t\n self.vocabulary = sorted(self.vocabulary)\n\t\t#print(\"Value of the vocabulary\")\n self.vocabulary_size = len(self.vocabulary)","def build_vocab(sentences_list, vocab_size, visual_fld):\n words = [word for sentence in sentences_list for word in sentence]\n utils.safe_mkdir(visual_fld)\n with open(os.path.join(visual_fld, 'vocab.tsv'), 'w') as fd:\n dictionary = {}\n index_dictionary = {}\n count = [('UNK', -1)]\n count.extend(Counter(words).most_common(vocab_size - 1))\n for index, (word, _) in enumerate(count):\n dictionary[word] = index\n index_dictionary[index] = word\n fd.write(word + '\\n')\n\n return dictionary, index_dictionary","def load_vocab():\n # vocab loaded internally at google\n unused = r.sp_model\n del unused\n return r","def _make_vocab_files(self):\n self.logger.info('making question vocab...' + self.opt.QUESTION_VOCAB_SPACE)\n qdic, _ = self.load_data(self.opt.QUESTION_VOCAB_SPACE)\n question_vocab = VQADataProvider.make_question_vocab(qdic, self.max_length)\n self.logger.info('making answer vocab...' + self.opt.ANSWER_VOCAB_SPACE)\n qdic, adic = self.load_data(self.opt.ANSWER_VOCAB_SPACE)\n answer_vocab = VQADataProvider.make_answer_vocab(adic, qdic, self.opt.MAX_ANSWER_VOCAB_SIZE, self.use_ocr)\n return question_vocab, answer_vocab","def setVocabulary(self, vocabulary): # real signature unknown; restored from __doc__\n pass","def create_vocabulary(\n data: Series,\n tokenizer_type: str = \"space\",\n lowercase: bool = True,\n num_most_frequent: int = None,\n vocab_file: str = None,\n add_special_symbols: bool = True,\n unknown_symbol: str = UNKNOWN_SYMBOL,\n padding_symbol: str = PADDING_SYMBOL,\n start_symbol: str = START_SYMBOL,\n stop_symbol: str = STOP_SYMBOL,\n pretrained_model_name_or_path: str = None,\n ngram_size: Optional[int] = None,\n compute_idf: bool = False,\n processor: DataFrameEngine = PANDAS,\n) -> Vocabulary:\n vocab = None\n\n tokenizer = get_tokenizer_from_registry(tokenizer_type)(\n vocab_file=vocab_file,\n pretrained_model_name_or_path=pretrained_model_name_or_path,\n ngram_size=ngram_size,\n )\n\n # Pre-trained huggingface tokenizer. Use the pre-existing vocabulary and special symbols.\n if tokenizer_type == \"hf_tokenizer\":\n try:\n vocab = tokenizer.get_vocab()\n vocab = list(vocab.keys())\n except NotImplementedError:\n logger.warning(\n \"HuggingFace tokenizer does not have a get_vocab() method. \"\n + \"Using tokenizer.tokenizer.vocab_size and tokenizer.tokenizer._convert_id_to_token \"\n + \"to build the vocabulary.\"\n )\n vocab = []\n for idx in range(tokenizer.tokenizer.vocab_size):\n vocab.append(tokenizer.tokenizer._convert_id_to_token(idx))\n vocab += tokenizer.tokenizer.added_tokens_encoder.keys()\n\n pad_token = tokenizer.get_pad_token()\n unk_token = tokenizer.get_unk_token()\n\n if unk_token is None:\n logger.warning(\n \"No unknown token found in HuggingFace tokenizer. Adding one. \"\n + \"NOTE: This will change the vocabulary size and may affect model \"\n + \"performance, particularly if the model weights are frozen.\"\n )\n vocab = [unknown_symbol] + vocab\n else:\n unknown_symbol = unk_token\n\n if pad_token is None and add_special_symbols:\n logger.warning(\n \"No padding token found in HuggingFace tokenizer. Adding one. \"\n + \"NOTE: This will change the vocabulary size and may affect model \"\n + \"performance, particularly if the model weights are frozen.\"\n )\n vocab = [padding_symbol] + vocab\n else:\n padding_symbol = pad_token\n elif hasattr(tokenizer, \"get_vocab\"):\n vocab = tokenizer.get_vocab()\n vocab = list(vocab.keys())\n elif vocab_file is not None:\n vocab = load_vocabulary(vocab_file)\n\n def process_line(line):\n return tokenizer(line.lower() if lowercase else line)\n\n processed_lines = processor.map_objects(data, process_line)\n processed_counts = processed_lines.explode().value_counts(sort=False)\n processed_counts = processor.compute(processed_counts)\n unit_counts = Counter(dict(processed_counts))\n\n doc_unit_counts = None\n if compute_idf:\n # The document frequency used for TF-IDF. Similar to unit_counts, but de-duped by document.\n document_counts = processed_lines.map(lambda x: set(x)).explode().value_counts(sort=False)\n document_counts = processor.compute(document_counts)\n doc_unit_counts = Counter(dict(document_counts))\n\n line_length_max = processor.compute(processed_lines.map(len).max())\n line_length_99ptile = processor.compute(processed_lines.map(len).quantile(0.99))\n\n if vocab is None:\n vocab = [unit for unit, _ in unit_counts.most_common(num_most_frequent)]\n\n vocab_set = set(vocab)\n\n if tokenizer_type != \"hf_tokenizer\":\n if add_special_symbols:\n add_or_move_symbol(vocab, vocab_set, stop_symbol, SpecialSymbol.STOP.value)\n add_or_move_symbol(vocab, vocab_set, start_symbol, SpecialSymbol.START.value)\n add_or_move_symbol(vocab, vocab_set, padding_symbol, SpecialSymbol.PADDING.value)\n # Always add the UNKNOWN symbol if we're using our own tokenizer.\n add_or_move_symbol(vocab, vocab_set, unknown_symbol, SpecialSymbol.UNKNOWN.value)\n\n str2idx = {unit: i for i, unit in enumerate(vocab)}\n str2freq = {unit: unit_counts.get(unit) if unit in unit_counts else 0 for unit in vocab}\n str2idf = (\n {unit: np.log(len(vocab) / (1 + doc_unit_counts.get(unit))) if unit in doc_unit_counts else 0 for unit in vocab}\n if compute_idf\n else None\n )\n\n pad_idx = None\n if padding_symbol in str2idx.keys():\n pad_idx = str2idx[padding_symbol]\n\n return Vocabulary(\n vocab=vocab,\n str2idx=str2idx,\n str2freq=str2freq,\n str2idf=str2idf,\n line_length_max=line_length_max,\n line_length_99ptile=line_length_99ptile,\n pad_idx=pad_idx,\n padding_symbol=padding_symbol,\n unknown_symbol=unknown_symbol,\n )","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences)) # 实际没用到\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n vocabulary_inv = list(sorted(vocabulary_inv))\n # 加入 <UNK>\n vocabulary_inv.insert(0, '</s>')\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def GetVocab(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def build_vocabulary(self, tokens=None, embeddings=None):\n if tokens is not None and embeddings is not None:\n raise ValueError(\"Only accepts either `tokens` or `embeddings`.\")\n\n if tokens is not None:\n # Build from tokenized tokens\n # for sentence in tqdm(tokens):\n # for word in tokens:\n # print(type(word))\n # exit()\n self.vocab.extend(\n list(set([\n word\n for sentence in tqdm(tokens)\n for word in sentence\n ]))\n )\n elif embeddings is not None:\n # Build from pretrained embeddings\n for word in tqdm(embeddings):\n word = word.strip(\"\\n\")\n word = word.split(\" \")\n\n self.vocab.append(word[0])\n vector = word[1:]\n self.vectors.append(vector)","def __init__(self, vocabulary, max_completions=5):\n self._vocabulary = vocabulary\n self._max_completions = max_completions","def vocab_from_json(path: str) -> Dict:\n with open(path, encoding=VOCAB_ENCODING) as inp:\n vocab = json.load(inp)\n logger.info('Vocabulary (%d words) loaded from \"%s\"', len(vocab), path)\n return vocab","def _insert_vocab(self, json_obj, mode=InsertVocabMode.ALL):\n raise NotImplementedError","def create_vocab():\n \n cutoff = CUTOFF\n \n lines = open(INFNAME_FORMAT.format(\"train\")).readlines() \\\n + open(INFNAME_FORMAT.format(\"test\")).readlines()\n raw = [process_line(l) for l in lines]\n cntx = Counter( [ w for e in raw for w in e ] )\n vocab = { x for x, y in cntx.items() if y > cutoff }\n \n return vocab","def load_vocabulary():\n global vocabulary_list, vocabulary_dict\n vocabulary_list = []\n vocabulary_dict = {}\n\n with open(_VOCABULARY_PATH, 'r') as f:\n for index, line in enumerate(f):\n line = line.strip()\n vocabulary_dict[line] = index\n vocabulary_list.append(line)","def build_vocab(cleaned_captions):\n # QUESTION 1.1\n # Here we Build a vocabulary\n\n # create a vocab instance\n vocab = Vocabulary()\n\n words = dict()\n for caption in cleaned_captions: # iterate through all cleaned_caption\n for word in caption.split(): # iterate over all words in a caption\n # add the token words to vocabulary if and only if the count of word is more than MIN_FREQUENCY i.e. 3\n if word not in words.keys():\n words[word] = 1\n else:\n words[word] += 1\n if words[word] > MIN_FREQUENCY:\n vocab.add_word(word)\n\n vocab.add_word('<pad>')\n vocab.add_word('<start>')\n vocab.add_word('<end>')\n vocab.add_word('<unk>')\n\n print(vocab.idx)\n\n return vocab","def create(cls, dictionary):\n return cls(**dictionary)","def create(cls, dictionary):\n return cls(**dictionary)","def build_vocab(sentences, saved_vocabulary_inv):\n if saved_vocabulary_inv:\n vocabulary_inv = saved_vocabulary_inv\n else:\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n vocabulary_inv.append('<pad>')\n vocabulary_inv = list(sorted(vocabulary_inv))\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def trainingsVocabulary(context):\n ct = getToolByName(context,'portal_catalog')\n dictSearch = {'portal_type':'apyb.papers.training',\n 'sort_on':'sortable_title',\n 'review_state':'confirmed'}\n trainings = ct.searchResults(**dictSearch)\n trainings = [SimpleTerm(b.UID,b.UID,b.Title) for b in trainings]\n return SimpleVocabulary(trainings)","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n vocabulary_inv = list(sorted(vocabulary_inv))\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def generate_vocabulary():\n stop_words = load_stop_words()\n words = ' '.join(generate_corpus()).split()\n print(len(words))\n vocabulary = {}\n for word in words:\n if word in stop_words:\n continue\n if word in vocabulary.keys():\n vocabulary[word] += 1\n else:\n vocabulary[word] = 1\n vocabulary = dict(sorted(vocabulary.items(), key=lambda x: x[1], reverse=True))\n return vocabulary","def speakersVocabulary(context):\n ct = getToolByName(context,'portal_catalog')\n dictSearch = {'portal_type':'apyb.papers.speaker','sort_on':'sortable_title'}\n speakers = ct.searchResults(**dictSearch)\n speakers = [SimpleTerm(b.UID,b.UID,b.Title) for b in speakers]\n return SimpleVocabulary(speakers)","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common() if x[1] > 1]\n vocabulary_inv += ['$']\n vocabulary_inv = list(sorted(vocabulary_inv))\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def process_vocabulary(args, data, quiet=False):\n if not quiet:\n out(args.logfile, \"initializing vacabularies... \", end=\"\")\n seq_vocab = vocabulary.Vocabulary()\n bracket_vocab = vocabulary.Vocabulary()\n # loop_type_vocab = vocabulary.Vocabulary()\n\n for vocab in [seq_vocab, bracket_vocab]: # , loop_type_vocab]:\n vocab.index(START)\n vocab.index(STOP)\n for x in data[:100]:\n seq = x[\"sequence\"]\n dot = x[\"structure\"]\n # loop = x[\"predicted_loop_type\"]\n for character in seq:\n seq_vocab.index(character)\n for character in dot:\n bracket_vocab.index(character)\n # for character in loop:\n # loop_type_vocab.index(character)\n for vocab in [seq_vocab, bracket_vocab]: # , loop_type_vocab]:\n # vocab.index(UNK)\n vocab.freeze()\n if not quiet:\n out(args.logfile, \"done.\")\n\n def print_vocabulary(name, vocab):\n # special = {START, STOP, UNK}\n special = {START, STOP}\n out(args.logfile, \"{}({:,}): {}\".format(\n name, vocab.size,\n sorted(value for value in vocab.values if value in special) +\n sorted(value for value in vocab.values if value not in special)))\n\n if not quiet:\n print_vocabulary(\"Sequence\", seq_vocab)\n print_vocabulary(\"Brackets\", bracket_vocab)\n return seq_vocab, bracket_vocab","def make_vocab(src_hparams, tgt_hparams):\n src_vocab = MonoTextData.make_vocab(src_hparams)\n\n if tgt_hparams[\"processing_share\"]:\n tgt_bos_token = src_hparams[\"bos_token\"]\n tgt_eos_token = src_hparams[\"eos_token\"]\n else:\n tgt_bos_token = tgt_hparams[\"bos_token\"]\n tgt_eos_token = tgt_hparams[\"eos_token\"]\n tgt_bos_token = utils.default_str(tgt_bos_token,\n SpecialTokens.BOS)\n tgt_eos_token = utils.default_str(tgt_eos_token,\n SpecialTokens.EOS)\n if tgt_hparams[\"vocab_share\"]:\n if tgt_bos_token == src_vocab.bos_token and \\\n tgt_eos_token == src_vocab.eos_token:\n tgt_vocab = src_vocab\n else:\n tgt_vocab = Vocab(src_hparams[\"vocab_file\"],\n bos_token=tgt_bos_token,\n eos_token=tgt_eos_token)\n else:\n tgt_vocab = Vocab(tgt_hparams[\"vocab_file\"],\n bos_token=tgt_bos_token,\n eos_token=tgt_eos_token)\n\n return src_vocab, tgt_vocab","def vocab_from_pickle(path: str) -> Dict:\n with open(path, \"rb\") as inp:\n vocab = pickle.load(inp)\n logger.info('Vocabulary (%d words) loaded from \"%s\"', len(vocab), path)\n return vocab","def build_vocab(words, vocab_size, visual_fld=None):\n utils.safe_mkdir(visual_fld)\n file = open(os.path.join(visual_fld, 'vocab.tsv'), 'w',encoding='utf8')\n\n dictionary = dict()\n count = [('UNK', -1)]\n index = 0\n count.extend(Counter(words).most_common(vocab_size - 1))\n\n for word, _ in count:\n dictionary[word] = index\n index += 1\n file.write(word + '\\n')\n\n index_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n file.close()\n return dictionary, index_dictionary","def load_vocab(vocab: Union[str, Vocab]) -> Vocab:\n if isinstance(vocab, Vocab):\n return vocab\n elif isinstance(vocab, str):\n return Vocab.load(vocab)\n else:\n raise NotImplementedError('Type of the input vocab is not supported. '\n 'We only support \"str\" or \"Vocab\". type(vocab) = \"{}\".'\n .format(type(vocab)))","def create_bpe_vocabulary(bpe_vocab_fp, bpe_int_fp, data_path, truecaser_fp):\n bpe = BPE(glossaries=SPECIAL_TOKENS)\n bpe.load(bpcodes_fp=bpe_int_fp, merges=-1)\n\n tcaser = MosesTruecaser(load_from=truecaser_fp, is_asr=True)\n tcase_func = partial(tcaser.truecase, return_str=True, use_known=True)\n unsup_tok_func = lambda x: bpe.tokenize(tcase_func(x).split())\n\n # PIPELINES AND VOCAB #\n\n vocab_pipeline = assemble_vocab_pipeline(text_fname=InpDataF.REV_TEXT,\n lowercase=False,\n tok_func=unsup_tok_func)\n subword_vocab = Vocabulary(vocab_pipeline, name_prefix=\"word\",\n special_tokens=SPECIAL_TOKENS)\n subword_vocab.create(data_source={\"data_path\": data_path}, max_size=None,\n data_fnames=InpDataF.REV_TEXT)\n subword_vocab.write(bpe_vocab_fp, sep=' ')","def __init__(self):\n self.sess = tf.Session()\n vocab_path = os.path.join(params.data_dir, \"vocab%d\" % params.vocab_size)\n self.vocab, self.rev_vocab = data_utils.initialize_vocabulary(vocab_path)\n self.model = model_utils.create_model(self.sess, True)\n self.model.batch_size = 1 # Respond 1 sentence at a time.","def get_vocab(which_vocab):\n path = os.path.join(mg.WORKING_PATH, 'vocab', ''.join([which_vocab, '.json'\n ]))\n if os.path.exists(path):\n with open(path, 'r') as js:\n return(json.load(js))\n else:\n return(dict())","def ensure_vocabulary(name):\n vocab = read_vocabulary_by_name(name)\n if vocab is None:\n return create_vocabulary(name)\n return vocab['id']","def make_corpus(self, t, v=None):\n v = self.vectorizer\n\n try:\n corpus = v.transform(t)\n except ValueError, e:\n return None, None\n \n vocab = {y:x for x,y in v.vocabulary_.iteritems()}\n corpus = gensim.matutils.Sparse2Corpus(corpus, documents_columns=False)\n return corpus, vocab","def load_vocabulary(self):\n vocab_file = open(vocabulary_path, \"r\")\n self.vocab_list = vocab_file.read().split(\"\\n\")\n vocab_file.close()\n print(\"[INFO] Reading vocabulary...\")\n print(self.vocab_list[0:15])","def build_vocab(data):\n # data = _read_words(filename)\n counter = collections.Counter(data)\n # print('counter', counter) # dictionary for the occurrence number of each word, e.g. 'banknote': 1, 'photography': 1, 'kia': 1\n count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))\n # print('count_pairs',count_pairs) # convert dictionary to list of tuple, e.g. ('ssangyong', 1), ('swapo', 1), ('wachter', 1)\n words, _ = list(zip(*count_pairs))\n word_to_id = dict(zip(words, range(len(words))))\n # print(words) # list of words\n # print(word_to_id) # dictionary for word to id, e.g. 'campbell': 2587, 'atlantic': 2247, 'aoun': 6746\n return word_to_id","def create_vocabs(self):\r\n print('Creating vocabs...')\r\n\r\n # Update surface_char2id\r\n unique_surfaces = set(chain(*[sentence.surface_words for sentence in self.sentences]))\r\n unique_chars = set(chain(*[surface for surface in unique_surfaces]))\r\n for ch in unique_chars:\r\n self.surface_char2id[ch] = len(self.surface_char2id)\r\n\r\n # Update lemma_char2id\r\n unique_lemmas = set(chain(*[sentence.lemmas for sentence in self.sentences]))\r\n unique_chars = set(chain(*[lemma for lemma in unique_lemmas]))\r\n for ch in unique_chars:\r\n self.lemma_char2id[ch] = len(self.lemma_char2id)\r\n\r\n # Update transformation2id\r\n for sentence in self.sentences:\r\n for transformation in sentence.transformations:\r\n for _t in transformation:\r\n if _t not in self.transformation2id:\r\n self.transformation2id[_t] = len(self.transformation2id)\r\n\r\n # Update morph_tag2id\r\n unique_morph_tags = list(chain(*[sentence.morph_tags for sentence in self.sentences]))\r\n unique_tags = set(chain(*[morph_tag for morph_tag in unique_morph_tags]))\r\n for tag in unique_tags:\r\n self.morph_tag2id[tag] = len(self.morph_tag2id)\r\n print('Surface Chars={}, Lemma Chars={}, Transformations={}, tags={}'.format(\r\n len(self.surface_char2id), len(self.lemma_char2id), len(self.transformation2id), len(self.morph_tag2id)\r\n ))","def create_choice(question, choice_text, votes=0):\n return question.choice_set.create(choice_text=choice_text, votes=votes)","def _init_vocab(self):\n self._word2idx = {}\n self._idx2word = {}\n self.freqs = {}\n self.vocab_size = 0\n\n self._add_word(self.pad_word)\n self._add_word(self.start_word)\n self._add_word(self.end_word)\n self._add_word(self.unk_word)\n\n self.start_word_idx = self.stoi(self.start_word)\n self.end_word_idx = self.stoi(self.end_word)\n self.unk_word_idx = self.stoi(self.unk_word)\n self.pad_word_idx = self.stoi(self.pad_word)\n\n self._special_tokens = {\n 'bos_token': self.start_word,\n 'cls_token': self.start_word,\n 'eos_token': self.end_word,\n 'sep_token': self.end_word,\n 'pad_token': self.pad_word,\n 'unk_token': self.unk_word,\n }\n\n self._special_ids = {\n 'bos_token_id': self.start_word_idx,\n 'cls_token_id': self.start_word_idx,\n 'eos_token_id': self.end_word_idx,\n 'sep_token_id': self.end_word_idx,\n 'pad_token_id': self.pad_word_idx,\n 'unk_token_id': self.unk_word_idx,\n }\n\n self.cls_token_id = self.bos_token_id = self.start_word_idx\n self.eos_token_id = self.sep_token_id = self.end_word_idx\n self.pad_token_id = self.pad_word_idx\n self.unk_token_id = self.unk_word_idx\n\n self.cls_token = self.bos_token = self.start_word\n self.eos_token = self.sep_token = self.end_word\n self.pad_token = self.pad_word\n self.unk_token = self.unk_word","def __repr__(self):\n l1 = \", \".join(\"{}={}\".format(x,y) for x,y in self._loading_params.items())\n l2 = \"max_vocab_size={}, min_token_freq={}, max_token_freq={}, ngrams={}\".format(\n self._max_vocab_size if hasattr(self, \"_max_vocab_size\") else None,\n self._min_token_freq if hasattr(self, \"_min_token_freq\") else 0,\n self._max_token_freq if hasattr(self, \"_max_token_freq\") else None,\n self._ngrams if hasattr(self, \"_ngrams\") else [1,1]\n )\n desc = \"Vocabulary({}, {})\".format(l1, l2)\n return desc","def __init__(\n self, values: Set, name: str, namespace: Optional[str] = None,\n label: Optional[str] = None, description: Optional[str] = None\n ):\n super(VocabularyHandle, self).__init__(\n name=name,\n namespace=namespace,\n label=label,\n description=description\n )\n self.values = values","def save_vocabulary(path, vocab):\n print('saving vocabulary..')\n with open(path, 'wb') as handle:\n pickle.dump(vocab, handle, protocol=pickle.HIGHEST_PROTOCOL)\n print('vocabulary was saved successfully!')","def create_vocab(vocab_size):\n vocab_dict = tff.simulation.datasets.stackoverflow.load_word_counts(\n cache_dir='/tmp')\n return list(vocab_dict.keys())[:vocab_size]","def build_vocab(path, fname):\r\n\twords = open(path, 'r', encoding='utf-8').read().split()\r\n\twordCount = Counter(words)\r\n\tif not os.path.exists(pm.vocab_path):\r\n\t\tos.makedirs(pm.vocab_path)\r\n\twith open(pm.vocab_path + fname, 'w', encoding='utf-8') as f:\r\n\t\tf.write(\"{}\\t1000000000\\n{}\\t1000000000\\n{}\\t1000000000\\n{}\\t1000000000\\n\".format(\"<PAD>\", \"<UNK>\", \"<SOS>\", \"<EOS>\"))\r\n\t\tfor word, count in wordCount.most_common(len(wordCount)):\r\n\t\t\tf.write(u\"{}\\t{}\\n\".format(word, count))","def generate_vocab():\n\n vocab_dict = {}\n folder_path = os.listdir(args.f)\n for subfolder in folder_path:\n subfolder_path = os.path.join(args.f, subfolder)\n for filename in os.listdir(subfolder_path):\n with open(os.path.join(subfolder_path, filename), 'r') as file:\n read_file = file.read()\n normalised_text = re.sub(r\"[^\\s\\w]\", \" \", read_file.lower())\n vocab = normalised_text.split() #.split() creates a list of strings\n vocab_dict.update({i: 0 for i in vocab})\n return vocab_dict","def load_vocab(path, encoding=\"UTF-9\"):\n vocab = []\n\n if not os.path.exists(path):\n return vocab\n\n with open(path, encoding=encoding) as fin:\n for line in fin.readlines():\n line = line.strip()\n word, freq = line.split(\"\\t\")\n vocab.append((word,int(freq)))\n\n return vocab","def build_vocab(self, sentences, keep_raw_vocab=False, trim_rule=None, progress_per=10000, update=False):\n print(\"build------------------\")\n self.scan_vocab(sentences, progress_per=progress_per, trim_rule=trim_rule) # initial survey\n # trim by min_count & precalculate downsampling\n self.scale_vocab(trim_rule=trim_rule, update=update)\n self.finalize_vocab(update=update)","def from_dataset(cls, dataset, col_names, vocab_size, character_coverage, model_type, params):\n\n vocab = SentencePieceVocab()\n root = copy.deepcopy(dataset).build_sentencepiece_vocab(vocab, col_names, vocab_size, character_coverage,\n model_type, params)\n for d in root.create_dict_iterator(num_epochs=1):\n if d is None:\n raise ValueError(\"from_dataset should receive data other than None.\")\n return vocab","def get_vocabulary(self, vocid, lang=None):\n\n payload = {}\n if lang is not None:\n payload['lang'] = lang\n req = requests.get(self.api_base + vocid + '/', params=payload)\n if req.status_code == 404:\n raise ValueError(req.text)\n req.raise_for_status()\n return req.json()","def list(self, request, format=None):\n queryset = Vocab.objects.all()\n serializer = VocabSerializer(queryset, context={\"request\": request})\n return Response(serializer.data)","def build_vocab(captions, threshold=0):\n\n\tcounter = Counter()\n\tfor caption in captions:\n\t\ttokens = caption.lower().split('/') \n\t\tcounter.update(tokens)\n\n\n\t# If the word frequency is less than 'threshold', then the word is discarded.\n\twords = [word for word, cnt in counter.items() if cnt >= threshold]\n\t# Creates a vocab wrapper and add some special tokens.\n\tvocab = Vocabulary()\n\tvocab.add_word('<pad>')\n\tvocab.add_word('<start>')\n\tvocab.add_word('<end>')\n\tvocab.add_word('<unk>')\n\n\t# Adds the words to the vocabulary.\n\tfor i, word in enumerate(words):\n\t\tvocab.add_word(word)\n\treturn vocab"],"string":"[\n \"def vocab():\\n symbols = DEFAULT_SPECIAL_SYMBOLS + [\\\"mouse\\\", \\\"dog\\\", \\\"tree\\\"]\\n return Vocabulary(symbols)\",\n \"def from_dict(cls, dikt: dict) -> 'Vocabulary':\\n return util.deserialize_model(dikt, cls)\",\n \"def create_vocab(vocab_path='ORBvoc-synth.txt'):\\n total_time = 10 # seconds\\n num_frames = 20\\n speed = 3.0\\n vocab_builder = VocabularyBuilder()\\n for seed in tqdm(range(100), total=100):\\n image_builder = DemoImageBuilder(\\n mode=ImageMode.MONOCULAR, seed=seed,\\n length=total_time * speed\\n )\\n for idx in range(num_frames):\\n time = total_time * idx / num_frames\\n image = image_builder.create_frame(time)\\n vocab_builder.add_image(image.pixels)\\n vocab_builder.build_vocabulary(str(vocab_path))\",\n \"def create(self, vocabulary=list) -> dict:\\n try:\\n out = {}\\n for i in range(len(vocabulary)):\\n out[vocabulary[i]] = i\\n return(out)\\n except Exception as error:\\n print(f\\\"Error: self.create([...]) -> {error}\\\")\",\n \"def create_vocab(\\n self,\\n instance_datasets: Iterable[InstanceDataset],\\n config: Optional[VocabularyConfiguration] = None,\\n ) -> Vocabulary:\\n # The transformers feature comes with its own vocab, no need to create anything if it is the only feature\\n if self.config.features.configured_namespaces == [\\n TransformersFeatures.namespace\\n ]:\\n return self.vocab\\n\\n self._check_for_word_vector_weights_file()\\n\\n config = config or VocabularyConfiguration()\\n\\n vocab = Vocabulary.from_instances(\\n instances=(\\n instance for dataset in instance_datasets for instance in dataset\\n ),\\n max_vocab_size=config.max_vocab_size,\\n min_count=config.min_count,\\n pretrained_files=config.pretrained_files,\\n only_include_pretrained_words=config.only_include_pretrained_words,\\n min_pretrained_embeddings=config.min_pretrained_embeddings,\\n tokens_to_add=config.tokens_to_add,\\n )\\n\\n # If the vocab is the same, this is just a no-op\\n self._model.extend_vocabulary(vocab)\\n\\n return vocab\",\n \"def create_vocabulary(vocabulary_path, json_vocab_path):\\n if not gfile.Exists(vocabulary_path):\\n print(\\\"Transform vocabulary to %s\\\" % vocabulary_path)\\n with gfile.GFile(json_vocab_path, mode=\\\"rb\\\") as f:\\n jvocab = json.load(f)\\n vocab = jvocab['w2id']\\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get)\\n with gfile.GFile(vocabulary_path, mode=\\\"wb\\\") as vocab_file:\\n for w in vocab_list:\\n vocab_file.write(w + b\\\"\\\\n\\\")\",\n \"def make_vocab(corpus_dictionary, vocab_path):\\n with open(vocab_path, 'wb') as fout:\\n pickle.dump(corpus_dictionary, fout)\\n print('Saved dictionary to', vocab_path)\",\n \"def load(cls, path: str) -> 'Vocab':\\n with open(path, 'r', encoding='utf-8') as f:\\n return cls.from_json(f.read())\",\n \"def vocabulary(self, config=Config()):\\n raise NotImplementedError(\\\"Class %s doesn't implement vocabulary()\\\" % self.__class__.__name__)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"rb\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"r\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if os.path.exists(vocabulary_path):\\n rev_vocab = []\\n with codecs_open(vocabulary_path, \\\"rb\\\", encoding=\\\"utf-8\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"rb\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [tf.compat.as_bytes(line.strip()) for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"rb\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"rb\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"r\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def __init__(self, vocabulary_size=1000):\\n self.vocabulary_size = vocabulary_size\",\n \"def create_vocabulary(sentences, path):\\n print('creating vocab..')\\n\\n word_dict = dict(); vocabulary = dict()\\n for sentence in sentences:\\n for word in nltk.word_tokenize(sentence):\\n if word not in word_dict:\\n word_dict[word] = ''\\n word_dict['<s>'] = ''\\n word_dict['</s>'] = ''\\n\\n with open(path, encoding=\\\"utf8\\\") as f:\\n for line in f:\\n word, vec = line.split(' ', 1)\\n if word in word_dict:\\n vocabulary[word] = np.fromstring(vec, sep=' ')\\n\\n print('vocabulary was created successfully!')\\n return vocabulary\",\n \"def _create_vocab(captions):\\n print(\\\"Creating vocabulary.\\\")\\n min_word_count = 4\\n word_counts_output_file = '/Users/lzg/Desktop/image_caption/word_count.txt'\\n counter = Counter()\\n for c in captions:\\n counter.update(c)\\n print(\\\"Total words:\\\", len(counter))\\n\\n # Filter uncommon words and sort by descending count.\\n word_counts = [x for x in counter.items() if x[1] >= min_word_count]\\n word_counts.sort(key=lambda x: x[1], reverse=True)\\n print(\\\"Words in vocabulary:\\\", len(word_counts))\\n\\n # Write out the word counts file.\\n with tf.gfile.FastGFile(word_counts_output_file, \\\"w\\\") as f:\\n f.write(\\\"\\\\n\\\".join([\\\"%s %d\\\" % (w, c) for w, c in word_counts]))\\n print(\\\"Wrote vocabulary file:\\\", word_counts_output_file)\\n\\n # Create the vocabulary dictionary.\\n reverse_vocab = [x[0] for x in word_counts]\\n unk_id = len(reverse_vocab)\\n vocab_dict = dict([(x, y) for (y, x) in enumerate(reverse_vocab)])\\n # vocab = Vocabulary(vocab_dict, unk_id)\\n\\n return vocab_dict, unk_id\",\n \"def getVocabulary(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def load(cls, w2v_vocab):\\n n2v_vocab = cls()\\n for key, value in w2v_vocab.__dict__.items():\\n setattr(n2v_vocab, key, value)\\n return n2v_vocab\",\n \"def getVocabulary(vocabulary_id):\\n relex_web = getSite().restrictedTraverse('relex_web')\\n key = KEY_STORAGE + \\\".\\\" + vocabulary_id\\n vocabulary = json.loads(getattr(relex_web, key, \\\"[]\\\"))\\n return vocabulary\",\n \"def from_list(texts, max_size=None, min_freq=None, tokenizer=None):\\n \\n if tokenizer is None:\\n tokenizer = Preprocess([\\n Consecutive(),\\n RemoveEmoji(),\\n WordTokenizer()\\n ])\\n\\n vocab = Vocabulary(\\n max_size=max_size,\\n min_freq=min_freq)\\n\\n token_lst = tokenizer(texts)\\n vocab.build_vocab(token_lst)\\n\\n return vocab\",\n \"def create_vocab(input_iter, min_frequency):\\n vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor(\\n FLAGS.max_sentence_len,\\n min_frequency=min_frequency,\\n tokenizer_fn=tokenizer_fn)\\n\\n vocab_processor.fit(input_iter)\\n return vocab_processor\",\n \"def create_vocabulary(vocabulary_path, data_paths, max_vocabulary_size,\\n tokenizer=None, normalize_digits=True):\\n if not gfile.Exists(vocabulary_path):\\n vocab = {}\\n files = []\\n files += [data_paths+f for f in os.listdir(data_paths) ]\\n for one_file in files:\\n with gfile.GFile(one_file, mode=\\\"rb\\\") as f:\\n review = f.read()\\n tokens = tokenizer(review) if tokenizer else character_tokenizer(review)\\n for w in tqdm(tokens):\\n word = _DIGIT_RE.sub(b\\\"0\\\", w) if normalize_digits else w\\n if word in vocab:\\n vocab[word] += 1\\n else:\\n vocab[word] = 1\\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\\n if len(vocab_list) > max_vocabulary_size:\\n vocab_list = vocab_list[:max_vocabulary_size]\\n with gfile.GFile(vocabulary_path, mode=\\\"wb\\\") as vocab_file:\\n for w in vocab_list:\\n vocab_file.write(w + b\\\"\\\\n\\\")\\n else:\\n print(\\\"Vocabulary already created.\\\")\",\n \"def _load_vocab(vocab_file_name, language):\\n vocab = []\\n vocab_size = 0\\n #with codecs.getreader(\\\"utf-8\\\")(tf.gfile.GFile(vocab_file_name), \\\"rb\\\") as f:\\n with tf.gfile.GFile(vocab_file_name) as f:\\n for word in f:\\n vocab.append(word.strip())\\n vocab_size += 1\\n\\n if not EOS in vocab:\\n vocab = [EOS] + vocab\\n if not SOS in vocab:\\n vocab = [SOS] + vocab\\n if not UNK in vocab:\\n vocab = [UNK] + vocab\\n\\n reverse_dictionary = {}\\n new_vocab_file_name = vocab_file_name + \\\".new\\\"\\n with tf.gfile.GFile(new_vocab_file_name, \\\"wb\\\") as f:\\n reverse_dictionary = {}\\n i = 0\\n for word in vocab:\\n f.write(\\\"%s\\\\n\\\" % word)\\n reverse_dictionary.update({i : word})\\n i+=1\\n\\n vocab_table = tf.contrib.lookup.index_table_from_file(new_vocab_file_name, default_value = 0)\\n\\n eos_id_tensor = tf.cast(vocab_table.lookup(tf.constant(EOS)), tf.int32)\\n sos_id_tensor = tf.cast(vocab_table.lookup(tf.constant(SOS)), tf.int32)\\n\\n return Vocab(lang=language,\\n table=vocab_table,\\n size=vocab_size,\\n reverse_dict=reverse_dictionary,\\n sos_id_tensor=sos_id_tensor,\\n eos_id_tensor=eos_id_tensor)\",\n \"def load_vocab(fn):\\n return corpora.Dictionary.load(fn)\",\n \"def create_vocabulary(vocabulary_path, data_path, max_vocabulary_size,\\n tokenizer=None, normalize_digits=True):\\n if not gfile.Exists(vocabulary_path):\\n print(\\\"Creating vocabulary %s from data %s\\\" % (vocabulary_path, data_path))\\n vocab = {}\\n with gfile.GFile(data_path, mode=\\\"rb\\\") as f:\\n counter = 0\\n for line in f:\\n counter += 1\\n if counter % 100000 == 0:\\n print(\\\" processing line %d\\\" % counter)\\n tokens = tokenizer(line) if tokenizer else basic_tokenizer(line)\\n for w in tokens:\\n word = re.sub(_DIGIT_RE, b\\\"0\\\", w) if normalize_digits else w\\n if word in vocab:\\n vocab[word] += 1\\n else:\\n vocab[word] = 1\\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\\n if len(vocab_list) > max_vocabulary_size:\\n print(\\\"vocab too big\\\")\\n vocab_list = vocab_list[:max_vocabulary_size]\\n with gfile.GFile(vocabulary_path, mode=\\\"wb\\\") as vocab_file:\\n for w in vocab_list:\\n vocab_file.write(w + b\\\"\\\\n\\\")\",\n \"def deserialize(self, descriptor: Dict, data: List) -> ObjectHandle:\\n return VocabularyHandle(\\n values=set(data),\\n name=descriptor['name'],\\n namespace=descriptor['namespace'],\\n label=descriptor.get('label'),\\n description=descriptor.get('description')\\n )\",\n \"def create_vocabulary(vocabulary_path, data_path, max_vocabulary_size,\\n tokenizer=None, normalize_digits=True,\\n _DIGIT_RE=re.compile(br\\\"\\\\d\\\"),\\n _START_VOCAB=[b\\\"_PAD\\\", b\\\"_GO\\\", b\\\"_EOS\\\", b\\\"_UNK\\\"]):\\n if not gfile.Exists(vocabulary_path):\\n print(\\\"Creating vocabulary %s from data %s\\\" % (vocabulary_path, data_path))\\n vocab = {}\\n with gfile.GFile(data_path, mode=\\\"rb\\\") as f:\\n counter = 0\\n for line in f:\\n counter += 1\\n if counter % 100000 == 0:\\n print(\\\" processing line %d\\\" % counter)\\n tokens = tokenizer(line) if tokenizer else basic_tokenizer(line)\\n for w in tokens:\\n word = re.sub(_DIGIT_RE, b\\\"0\\\", w) if normalize_digits else w\\n if word in vocab:\\n vocab[word] += 1\\n else:\\n vocab[word] = 1\\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\\n if len(vocab_list) > max_vocabulary_size:\\n vocab_list = vocab_list[:max_vocabulary_size]\\n with gfile.GFile(vocabulary_path, mode=\\\"wb\\\") as vocab_file:\\n for w in vocab_list:\\n vocab_file.write(w + b\\\"\\\\n\\\")\\n else:\\n print(\\\"Vocabulary %s from data %s exists\\\" % (vocabulary_path, data_path))\",\n \"def create_restricted_vocabulary(field, options,\\n message_factory=None,\\n restricted=lambda x: True):\\n class GeneratedVocabulary(object):\\n\\n @property\\n def option_level_mapping(self):\\n option_level_mapping = [list(a) for a in self.options[:]]\\n option_level_mapping = dict([a for a in option_level_mapping\\n if not a.reverse()])\\n return option_level_mapping\\n\\n @property\\n def option_names(self):\\n return [a[1] for a in self.options]\\n\\n @property\\n def options(self):\\n if callable(self._options):\\n return self._options()\\n else:\\n return self._options\\n\\n def __call__(self, context):\\n self.context = context\\n\\n terms = []\\n for name in self.get_allowed_option_names():\\n title = name\\n if message_factory:\\n title = self._(name)\\n terms.append(\\n zope.schema.vocabulary.SimpleTerm(name, title=title))\\n return zope.schema.vocabulary.SimpleVocabulary(terms)\\n\\n def get_allowed_option_names(self):\\n acquisition_value = self._get_acquisiton_value()\\n\\n if not self.restricted():\\n return self.option_names\\n\\n if not acquisition_value or acquisition_value not in self.option_names:\\n return self.option_names\\n\\n allowed_option_names = []\\n allowed_option_names.append(acquisition_value)\\n allowed_level = self.option_level_mapping[acquisition_value] + 1\\n for level, name in self.options:\\n if level >= allowed_level:\\n allowed_option_names.append(name)\\n\\n return allowed_option_names\\n\\n def _get_acquisiton_value(self):\\n context = self.context\\n if isinstance(context, MetadataBase) or context is None:\\n # we do not test the factory, it is not acquisition wrapped and\\n # we cant get the request...\\n return None\\n request = self.context.REQUEST\\n # XXX CHANGED FROM PATH_TRANSLATED TO PATH_INFO\\n # because the test don't work\\n if '++add++' in request.get('PATH_INFO', ''):\\n # object is not yet existing, context is container\\n obj = context\\n else:\\n # object is existing, container is parent of context\\n obj = context.aq_inner.aq_parent\\n while not ISiteRoot.providedBy(obj):\\n try:\\n return self.field.get(obj)\\n except AttributeError:\\n try:\\n interface_ = self.field.interface\\n except AttributeError:\\n pass\\n else:\\n try:\\n adpt = interface_(obj)\\n except TypeError:\\n # could not adapt\\n pass\\n else:\\n return self.field.get(adpt)\\n obj = obj.aq_inner.aq_parent\\n return self.field.default\\n\\n GeneratedVocabulary.field = field\\n GeneratedVocabulary._options = options\\n GeneratedVocabulary._ = message_factory\\n GeneratedVocabulary.restricted = restricted\\n\\n return GeneratedVocabulary\",\n \"def create_vocabulary(vocabulary_path, words, max_vocabulary_size, normalize_digits=True):\\n if not gfile.Exists(vocabulary_path):\\n print(\\\"Creating vocabulary %s with max size %d\\\" % (vocabulary_path, max_vocabulary_size))\\n vocab = {}\\n counter = 0\\n for w in words:\\n counter += 1\\n if counter % 10000 == 0:\\n print(\\\" processing word %d = %s\\\" % (counter, w))\\n word = re.sub(_DIGIT_RE, \\\"0\\\", w) if normalize_digits else w\\n if word in vocab:\\n vocab[word] += 1\\n else:\\n vocab[word] = 1\\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\\n if len(vocab_list) > max_vocabulary_size:\\n vocab_list = vocab_list[:max_vocabulary_size]\\n with gfile.GFile(vocabulary_path, mode=\\\"w\\\") as vocab_file:\\n for w in vocab_list:\\n vocab_file.write(w + \\\"\\\\n\\\")\",\n \"def initialize_vocabulary(vocabulary_path):\\n characters_class = 9999\\n\\n if os.path.exists(vocabulary_path):\\n with codecs.open(vocabulary_path, 'r', encoding='utf-8') as voc_file:\\n rev_vocab = [line.strip() for line in voc_file]\\n\\n vocab = {x: y for (y, x) in enumerate(rev_vocab)}\\n\\n reserved_char_size = characters_class - len(rev_vocab)\\n if reserved_char_size < 0:\\n raise ValueError(\\\"Number of characters in vocabulary is equal or larger than config.characters_class\\\")\\n\\n for _ in range(reserved_char_size):\\n rev_vocab.append('')\\n\\n # put space at the last position\\n vocab[' '] = len(rev_vocab)\\n rev_vocab.append(' ')\\n return vocab, rev_vocab\\n\\n raise ValueError(\\\"Initializing vocabulary ends: %s\\\" % vocabulary_path)\",\n \"def create_vocabulary(vocabulary_path, data_path, max_vocabulary_size,\\n tokenizer=None, normalize_digits=True):\\n if not gfile.Exists(vocabulary_path):\\n print(\\\"Creating vocabulary %s from data %s\\\" % (vocabulary_path, data_path))\\n vocab = {}\\n with gfile.GFile(data_path, mode=\\\"r\\\") as f:\\n counter = 0\\n for line in f:\\n counter += 1\\n line = line.strip().split('\\\\t')[0]\\n if counter % 100000 == 0:\\n print(\\\" processing line %d\\\" % counter)\\n tokens = tokenizer(line) if tokenizer else basic_tokenizer(line)\\n for w in tokens:\\n word = re.sub(_DIGIT_RE, \\\"0\\\", w) if normalize_digits else w\\n if word in vocab:\\n vocab[word] += 1\\n else:\\n vocab[word] = 1\\n sorted_vocab = sorted(vocab, key=vocab.get, reverse=True)\\n vocab_list = _START_VOCAB + sorted_vocab\\n if len(vocab_list) > max_vocabulary_size:\\n vocab_list = vocab_list[:max_vocabulary_size]\\n print(\\\"Corpus %s has %d tokens, %d uniq words, %d vocab at cutoff %d.\\\" % (\\n data_path, sum(vocab.values()), len(vocab), max_vocabulary_size, vocab[sorted_vocab[max_vocabulary_size - len(_START_VOCAB)]] ) )\\n else:\\n print(\\\"Corpus %s has %d tokens, %d uniq words, %d vocab at cutoff %d.\\\" % (\\n data_path, sum(vocab.values()), len(vocab), len(vocab), 0))\\n\\n with gfile.GFile(vocabulary_path, mode=\\\"wb\\\") as vocab_file:\\n for w in vocab_list:\\n vocab_file.write(w + \\\"\\\\n\\\")\",\n \"def build_vocab(self):\\n if self.test_file is None:\\n print('test_file is None')\\n file_list = [self.train_file, self.dev_file]\\n else:\\n file_list = [self.train_file, self.dev_file, self.test_file]\\n\\n examples = []\\n for file_name in file_list:\\n examples += ParseExample.load_data(file_name)\\n\\n sents = []\\n for example in examples:\\n warrant0, warrant1, reason, claim, debate_meta_data, negclaim = example.get_six(type=WORD_TYPE)\\n sents.append(warrant0)\\n sents.append(warrant1)\\n sents.append(reason)\\n sents.append(claim)\\n sents.append(debate_meta_data)\\n\\n vocab = data_utils.build_word_vocab(sents)\\n\\n return vocab\",\n \"def from_pickle(pkl):\\n assert os.path.exists(pkl), f\\\"{pkl} not exists\\\"\\n with open(pkl, 'rb') as f:\\n vocab = pickle.load(f)\\n \\n return vocab\",\n \"def get_vocab(self):\\n if os.path.exists(self.vocab_file) & self.vocab_from_file:\\n f = open(self.vocab_file, \\\"rb\\\")\\n vocab = pickle.load(f)\\n self.word2idx = vocab.word2idx\\n self.idx2word = vocab.idx2word\\n f.close()\\n else:\\n self.build_vocab()\\n with open(self.vocab_file, 'wb') as f:\\n pickle.dump(self, f)\",\n \"def __init__(self, file):\\n with open(file, 'r') as f:\\n self.vocab = json.loads(f.read())\",\n \"def vocab(self) -> Vocabulary:\\n return self._model.vocab\",\n \"def initialize_vocabulary(self,vocabulary_path):\\n if tf.gfile.Exists(vocabulary_path):\\n vocab = corpora.Dictionary.load(vocabulary_path)\\n print(\\\"vocab length: \\\",len(vocab.token2id))\\n\\n return vocab.token2id, vocab.token2id.keys()\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def create_vocab_table(db, vocab):\\n con = lite.connect(db)\\n with con:\\n cur = con.cursor()\\n cur.execute(\\\"CREATE TABLE IF NOT EXISTS Vocab(vocab TEXT)\\\")\\n for i in range(0, len(vocab)):\\n vocab[i] = (vocab[i],)\\n with con:\\n cur = con.cursor()\\n cur.executemany(\\\"INSERT INTO Vocab VALUES (?)\\\", vocab)\",\n \"def load_vocab(path: str) -> Vocab:\\n return torch.load(path, map_location=lambda storage, loc: storage)['args'].vocab\",\n \"def buildVocabulary(paragraphs, verbose=True):\\n vocabulary = []\\n \\n for p in paragraphs:\\n for word in p.split():\\n vocabulary.append(word)\\n\\n vocabulary = set(vocabulary)\\n if verbose:\\n print('Built vocabulary of %d unique words'%len(vocabulary))\\n \\n return list(vocabulary)\",\n \"def load_vocab(self, fn):\\n vocab = load_vocab(fn)\\n self.vocab = vocab\\n self.has_vocab = True\",\n \"def get_vocab(self):\\n\\n\\t\\tself.parse_transcript() \\n\\t\\tself.purge_words()\\n\\t\\tself.analyze_words()\\n\\t\\tself.sort_word_analysis()\",\n \"def _build_vocabulary(input_files):\\n if FLAGS.vocab_file:\\n tf.logging.info(\\\"Loading existing vocab file.\\\")\\n vocab = collections.OrderedDict()\\n with tf.gfile.GFile(FLAGS.vocab_file, mode=\\\"r\\\") as f:\\n for i, line in enumerate(f):\\n word = line.decode(\\\"utf-8\\\").strip()\\n assert word not in vocab, \\\"Attempting to add word twice: %s\\\" % word\\n vocab[word] = i\\n tf.logging.info(\\\"Read vocab of size %d from %s\\\",\\n len(vocab), FLAGS.vocab_file)\\n return vocab\\n\\n tf.logging.info(\\\"Creating vocabulary.\\\")\\n num = 0\\n wordcount = collections.Counter()\\n for input_file in input_files:\\n tf.logging.info(\\\"Processing file: %s\\\", input_file)\\n for sentence in tf.gfile.FastGFile(input_file):\\n wordcount.update(sentence.split())\\n\\n num += 1\\n if num % 1000000 == 0:\\n tf.logging.info(\\\"Processed %d sentences\\\", num)\\n\\n tf.logging.info(\\\"Processed %d sentences total\\\", num)\\n\\n words = wordcount.keys()\\n freqs = wordcount.values()\\n sorted_indices = np.argsort(freqs)[::-1]\\n\\n vocab = collections.OrderedDict()\\n vocab[special_words.EOS] = special_words.EOS_ID\\n vocab[special_words.UNK] = special_words.UNK_ID\\n for w_id, w_index in enumerate(sorted_indices[0:FLAGS.num_words - 2]):\\n vocab[words[w_index]] = w_id + 2 # 0: EOS, 1: UNK.\\n\\n tf.logging.info(\\\"Created vocab with %d words\\\", len(vocab))\\n\\n vocab_file = os.path.join(FLAGS.output_dir, \\\"vocab.txt\\\")\\n with tf.gfile.FastGFile(vocab_file, \\\"w\\\") as f:\\n f.write(\\\"\\\\n\\\".join(vocab.keys()))\\n tf.logging.info(\\\"Wrote vocab file to %s\\\", vocab_file)\\n\\n word_counts_file = os.path.join(FLAGS.output_dir, \\\"word_counts.txt\\\")\\n with tf.gfile.FastGFile(word_counts_file, \\\"w\\\") as f:\\n for i in sorted_indices:\\n f.write(\\\"%s %d\\\\n\\\" % (words[i], freqs[i]))\\n tf.logging.info(\\\"Wrote word counts file to %s\\\", word_counts_file)\\n\\n return vocab\",\n \"def trackVocabulary(context):\\n ct = getToolByName(context,'portal_catalog')\\n tracks = ct.searchResults(portal_type='apyb.papers.track', sort_on='getObjPositionInParent')\\n items = [SimpleTerm(b.UID,b.UID,b.Title) for b in tracks]\\n return SimpleVocabulary(items)\",\n \"def build_vocabulary(self):\\n \\n for iCount in range(0,len(self.documents)):\\n for jCount in range(iCount,len(self.documents[iCount])):\\n self.vocabulary.append(self.documents[iCount][jCount])\\n\\n self.vocabulary = set(self.vocabulary)\\n\\t\\t\\n self.vocabulary = sorted(self.vocabulary)\\n\\t\\t#print(\\\"Value of the vocabulary\\\")\\n self.vocabulary_size = len(self.vocabulary)\",\n \"def build_vocab(sentences_list, vocab_size, visual_fld):\\n words = [word for sentence in sentences_list for word in sentence]\\n utils.safe_mkdir(visual_fld)\\n with open(os.path.join(visual_fld, 'vocab.tsv'), 'w') as fd:\\n dictionary = {}\\n index_dictionary = {}\\n count = [('UNK', -1)]\\n count.extend(Counter(words).most_common(vocab_size - 1))\\n for index, (word, _) in enumerate(count):\\n dictionary[word] = index\\n index_dictionary[index] = word\\n fd.write(word + '\\\\n')\\n\\n return dictionary, index_dictionary\",\n \"def load_vocab():\\n # vocab loaded internally at google\\n unused = r.sp_model\\n del unused\\n return r\",\n \"def _make_vocab_files(self):\\n self.logger.info('making question vocab...' + self.opt.QUESTION_VOCAB_SPACE)\\n qdic, _ = self.load_data(self.opt.QUESTION_VOCAB_SPACE)\\n question_vocab = VQADataProvider.make_question_vocab(qdic, self.max_length)\\n self.logger.info('making answer vocab...' + self.opt.ANSWER_VOCAB_SPACE)\\n qdic, adic = self.load_data(self.opt.ANSWER_VOCAB_SPACE)\\n answer_vocab = VQADataProvider.make_answer_vocab(adic, qdic, self.opt.MAX_ANSWER_VOCAB_SIZE, self.use_ocr)\\n return question_vocab, answer_vocab\",\n \"def setVocabulary(self, vocabulary): # real signature unknown; restored from __doc__\\n pass\",\n \"def create_vocabulary(\\n data: Series,\\n tokenizer_type: str = \\\"space\\\",\\n lowercase: bool = True,\\n num_most_frequent: int = None,\\n vocab_file: str = None,\\n add_special_symbols: bool = True,\\n unknown_symbol: str = UNKNOWN_SYMBOL,\\n padding_symbol: str = PADDING_SYMBOL,\\n start_symbol: str = START_SYMBOL,\\n stop_symbol: str = STOP_SYMBOL,\\n pretrained_model_name_or_path: str = None,\\n ngram_size: Optional[int] = None,\\n compute_idf: bool = False,\\n processor: DataFrameEngine = PANDAS,\\n) -> Vocabulary:\\n vocab = None\\n\\n tokenizer = get_tokenizer_from_registry(tokenizer_type)(\\n vocab_file=vocab_file,\\n pretrained_model_name_or_path=pretrained_model_name_or_path,\\n ngram_size=ngram_size,\\n )\\n\\n # Pre-trained huggingface tokenizer. Use the pre-existing vocabulary and special symbols.\\n if tokenizer_type == \\\"hf_tokenizer\\\":\\n try:\\n vocab = tokenizer.get_vocab()\\n vocab = list(vocab.keys())\\n except NotImplementedError:\\n logger.warning(\\n \\\"HuggingFace tokenizer does not have a get_vocab() method. \\\"\\n + \\\"Using tokenizer.tokenizer.vocab_size and tokenizer.tokenizer._convert_id_to_token \\\"\\n + \\\"to build the vocabulary.\\\"\\n )\\n vocab = []\\n for idx in range(tokenizer.tokenizer.vocab_size):\\n vocab.append(tokenizer.tokenizer._convert_id_to_token(idx))\\n vocab += tokenizer.tokenizer.added_tokens_encoder.keys()\\n\\n pad_token = tokenizer.get_pad_token()\\n unk_token = tokenizer.get_unk_token()\\n\\n if unk_token is None:\\n logger.warning(\\n \\\"No unknown token found in HuggingFace tokenizer. Adding one. \\\"\\n + \\\"NOTE: This will change the vocabulary size and may affect model \\\"\\n + \\\"performance, particularly if the model weights are frozen.\\\"\\n )\\n vocab = [unknown_symbol] + vocab\\n else:\\n unknown_symbol = unk_token\\n\\n if pad_token is None and add_special_symbols:\\n logger.warning(\\n \\\"No padding token found in HuggingFace tokenizer. Adding one. \\\"\\n + \\\"NOTE: This will change the vocabulary size and may affect model \\\"\\n + \\\"performance, particularly if the model weights are frozen.\\\"\\n )\\n vocab = [padding_symbol] + vocab\\n else:\\n padding_symbol = pad_token\\n elif hasattr(tokenizer, \\\"get_vocab\\\"):\\n vocab = tokenizer.get_vocab()\\n vocab = list(vocab.keys())\\n elif vocab_file is not None:\\n vocab = load_vocabulary(vocab_file)\\n\\n def process_line(line):\\n return tokenizer(line.lower() if lowercase else line)\\n\\n processed_lines = processor.map_objects(data, process_line)\\n processed_counts = processed_lines.explode().value_counts(sort=False)\\n processed_counts = processor.compute(processed_counts)\\n unit_counts = Counter(dict(processed_counts))\\n\\n doc_unit_counts = None\\n if compute_idf:\\n # The document frequency used for TF-IDF. Similar to unit_counts, but de-duped by document.\\n document_counts = processed_lines.map(lambda x: set(x)).explode().value_counts(sort=False)\\n document_counts = processor.compute(document_counts)\\n doc_unit_counts = Counter(dict(document_counts))\\n\\n line_length_max = processor.compute(processed_lines.map(len).max())\\n line_length_99ptile = processor.compute(processed_lines.map(len).quantile(0.99))\\n\\n if vocab is None:\\n vocab = [unit for unit, _ in unit_counts.most_common(num_most_frequent)]\\n\\n vocab_set = set(vocab)\\n\\n if tokenizer_type != \\\"hf_tokenizer\\\":\\n if add_special_symbols:\\n add_or_move_symbol(vocab, vocab_set, stop_symbol, SpecialSymbol.STOP.value)\\n add_or_move_symbol(vocab, vocab_set, start_symbol, SpecialSymbol.START.value)\\n add_or_move_symbol(vocab, vocab_set, padding_symbol, SpecialSymbol.PADDING.value)\\n # Always add the UNKNOWN symbol if we're using our own tokenizer.\\n add_or_move_symbol(vocab, vocab_set, unknown_symbol, SpecialSymbol.UNKNOWN.value)\\n\\n str2idx = {unit: i for i, unit in enumerate(vocab)}\\n str2freq = {unit: unit_counts.get(unit) if unit in unit_counts else 0 for unit in vocab}\\n str2idf = (\\n {unit: np.log(len(vocab) / (1 + doc_unit_counts.get(unit))) if unit in doc_unit_counts else 0 for unit in vocab}\\n if compute_idf\\n else None\\n )\\n\\n pad_idx = None\\n if padding_symbol in str2idx.keys():\\n pad_idx = str2idx[padding_symbol]\\n\\n return Vocabulary(\\n vocab=vocab,\\n str2idx=str2idx,\\n str2freq=str2freq,\\n str2idf=str2idf,\\n line_length_max=line_length_max,\\n line_length_99ptile=line_length_99ptile,\\n pad_idx=pad_idx,\\n padding_symbol=padding_symbol,\\n unknown_symbol=unknown_symbol,\\n )\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences)) # 实际没用到\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n vocabulary_inv = list(sorted(vocabulary_inv))\\n # 加入 <UNK>\\n vocabulary_inv.insert(0, '</s>')\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def GetVocab(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def build_vocabulary(self, tokens=None, embeddings=None):\\n if tokens is not None and embeddings is not None:\\n raise ValueError(\\\"Only accepts either `tokens` or `embeddings`.\\\")\\n\\n if tokens is not None:\\n # Build from tokenized tokens\\n # for sentence in tqdm(tokens):\\n # for word in tokens:\\n # print(type(word))\\n # exit()\\n self.vocab.extend(\\n list(set([\\n word\\n for sentence in tqdm(tokens)\\n for word in sentence\\n ]))\\n )\\n elif embeddings is not None:\\n # Build from pretrained embeddings\\n for word in tqdm(embeddings):\\n word = word.strip(\\\"\\\\n\\\")\\n word = word.split(\\\" \\\")\\n\\n self.vocab.append(word[0])\\n vector = word[1:]\\n self.vectors.append(vector)\",\n \"def __init__(self, vocabulary, max_completions=5):\\n self._vocabulary = vocabulary\\n self._max_completions = max_completions\",\n \"def vocab_from_json(path: str) -> Dict:\\n with open(path, encoding=VOCAB_ENCODING) as inp:\\n vocab = json.load(inp)\\n logger.info('Vocabulary (%d words) loaded from \\\"%s\\\"', len(vocab), path)\\n return vocab\",\n \"def _insert_vocab(self, json_obj, mode=InsertVocabMode.ALL):\\n raise NotImplementedError\",\n \"def create_vocab():\\n \\n cutoff = CUTOFF\\n \\n lines = open(INFNAME_FORMAT.format(\\\"train\\\")).readlines() \\\\\\n + open(INFNAME_FORMAT.format(\\\"test\\\")).readlines()\\n raw = [process_line(l) for l in lines]\\n cntx = Counter( [ w for e in raw for w in e ] )\\n vocab = { x for x, y in cntx.items() if y > cutoff }\\n \\n return vocab\",\n \"def load_vocabulary():\\n global vocabulary_list, vocabulary_dict\\n vocabulary_list = []\\n vocabulary_dict = {}\\n\\n with open(_VOCABULARY_PATH, 'r') as f:\\n for index, line in enumerate(f):\\n line = line.strip()\\n vocabulary_dict[line] = index\\n vocabulary_list.append(line)\",\n \"def build_vocab(cleaned_captions):\\n # QUESTION 1.1\\n # Here we Build a vocabulary\\n\\n # create a vocab instance\\n vocab = Vocabulary()\\n\\n words = dict()\\n for caption in cleaned_captions: # iterate through all cleaned_caption\\n for word in caption.split(): # iterate over all words in a caption\\n # add the token words to vocabulary if and only if the count of word is more than MIN_FREQUENCY i.e. 3\\n if word not in words.keys():\\n words[word] = 1\\n else:\\n words[word] += 1\\n if words[word] > MIN_FREQUENCY:\\n vocab.add_word(word)\\n\\n vocab.add_word('<pad>')\\n vocab.add_word('<start>')\\n vocab.add_word('<end>')\\n vocab.add_word('<unk>')\\n\\n print(vocab.idx)\\n\\n return vocab\",\n \"def create(cls, dictionary):\\n return cls(**dictionary)\",\n \"def create(cls, dictionary):\\n return cls(**dictionary)\",\n \"def build_vocab(sentences, saved_vocabulary_inv):\\n if saved_vocabulary_inv:\\n vocabulary_inv = saved_vocabulary_inv\\n else:\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n vocabulary_inv.append('<pad>')\\n vocabulary_inv = list(sorted(vocabulary_inv))\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def trainingsVocabulary(context):\\n ct = getToolByName(context,'portal_catalog')\\n dictSearch = {'portal_type':'apyb.papers.training',\\n 'sort_on':'sortable_title',\\n 'review_state':'confirmed'}\\n trainings = ct.searchResults(**dictSearch)\\n trainings = [SimpleTerm(b.UID,b.UID,b.Title) for b in trainings]\\n return SimpleVocabulary(trainings)\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n vocabulary_inv = list(sorted(vocabulary_inv))\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def generate_vocabulary():\\n stop_words = load_stop_words()\\n words = ' '.join(generate_corpus()).split()\\n print(len(words))\\n vocabulary = {}\\n for word in words:\\n if word in stop_words:\\n continue\\n if word in vocabulary.keys():\\n vocabulary[word] += 1\\n else:\\n vocabulary[word] = 1\\n vocabulary = dict(sorted(vocabulary.items(), key=lambda x: x[1], reverse=True))\\n return vocabulary\",\n \"def speakersVocabulary(context):\\n ct = getToolByName(context,'portal_catalog')\\n dictSearch = {'portal_type':'apyb.papers.speaker','sort_on':'sortable_title'}\\n speakers = ct.searchResults(**dictSearch)\\n speakers = [SimpleTerm(b.UID,b.UID,b.Title) for b in speakers]\\n return SimpleVocabulary(speakers)\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common() if x[1] > 1]\\n vocabulary_inv += ['$']\\n vocabulary_inv = list(sorted(vocabulary_inv))\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def process_vocabulary(args, data, quiet=False):\\n if not quiet:\\n out(args.logfile, \\\"initializing vacabularies... \\\", end=\\\"\\\")\\n seq_vocab = vocabulary.Vocabulary()\\n bracket_vocab = vocabulary.Vocabulary()\\n # loop_type_vocab = vocabulary.Vocabulary()\\n\\n for vocab in [seq_vocab, bracket_vocab]: # , loop_type_vocab]:\\n vocab.index(START)\\n vocab.index(STOP)\\n for x in data[:100]:\\n seq = x[\\\"sequence\\\"]\\n dot = x[\\\"structure\\\"]\\n # loop = x[\\\"predicted_loop_type\\\"]\\n for character in seq:\\n seq_vocab.index(character)\\n for character in dot:\\n bracket_vocab.index(character)\\n # for character in loop:\\n # loop_type_vocab.index(character)\\n for vocab in [seq_vocab, bracket_vocab]: # , loop_type_vocab]:\\n # vocab.index(UNK)\\n vocab.freeze()\\n if not quiet:\\n out(args.logfile, \\\"done.\\\")\\n\\n def print_vocabulary(name, vocab):\\n # special = {START, STOP, UNK}\\n special = {START, STOP}\\n out(args.logfile, \\\"{}({:,}): {}\\\".format(\\n name, vocab.size,\\n sorted(value for value in vocab.values if value in special) +\\n sorted(value for value in vocab.values if value not in special)))\\n\\n if not quiet:\\n print_vocabulary(\\\"Sequence\\\", seq_vocab)\\n print_vocabulary(\\\"Brackets\\\", bracket_vocab)\\n return seq_vocab, bracket_vocab\",\n \"def make_vocab(src_hparams, tgt_hparams):\\n src_vocab = MonoTextData.make_vocab(src_hparams)\\n\\n if tgt_hparams[\\\"processing_share\\\"]:\\n tgt_bos_token = src_hparams[\\\"bos_token\\\"]\\n tgt_eos_token = src_hparams[\\\"eos_token\\\"]\\n else:\\n tgt_bos_token = tgt_hparams[\\\"bos_token\\\"]\\n tgt_eos_token = tgt_hparams[\\\"eos_token\\\"]\\n tgt_bos_token = utils.default_str(tgt_bos_token,\\n SpecialTokens.BOS)\\n tgt_eos_token = utils.default_str(tgt_eos_token,\\n SpecialTokens.EOS)\\n if tgt_hparams[\\\"vocab_share\\\"]:\\n if tgt_bos_token == src_vocab.bos_token and \\\\\\n tgt_eos_token == src_vocab.eos_token:\\n tgt_vocab = src_vocab\\n else:\\n tgt_vocab = Vocab(src_hparams[\\\"vocab_file\\\"],\\n bos_token=tgt_bos_token,\\n eos_token=tgt_eos_token)\\n else:\\n tgt_vocab = Vocab(tgt_hparams[\\\"vocab_file\\\"],\\n bos_token=tgt_bos_token,\\n eos_token=tgt_eos_token)\\n\\n return src_vocab, tgt_vocab\",\n \"def vocab_from_pickle(path: str) -> Dict:\\n with open(path, \\\"rb\\\") as inp:\\n vocab = pickle.load(inp)\\n logger.info('Vocabulary (%d words) loaded from \\\"%s\\\"', len(vocab), path)\\n return vocab\",\n \"def build_vocab(words, vocab_size, visual_fld=None):\\n utils.safe_mkdir(visual_fld)\\n file = open(os.path.join(visual_fld, 'vocab.tsv'), 'w',encoding='utf8')\\n\\n dictionary = dict()\\n count = [('UNK', -1)]\\n index = 0\\n count.extend(Counter(words).most_common(vocab_size - 1))\\n\\n for word, _ in count:\\n dictionary[word] = index\\n index += 1\\n file.write(word + '\\\\n')\\n\\n index_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\\n file.close()\\n return dictionary, index_dictionary\",\n \"def load_vocab(vocab: Union[str, Vocab]) -> Vocab:\\n if isinstance(vocab, Vocab):\\n return vocab\\n elif isinstance(vocab, str):\\n return Vocab.load(vocab)\\n else:\\n raise NotImplementedError('Type of the input vocab is not supported. '\\n 'We only support \\\"str\\\" or \\\"Vocab\\\". type(vocab) = \\\"{}\\\".'\\n .format(type(vocab)))\",\n \"def create_bpe_vocabulary(bpe_vocab_fp, bpe_int_fp, data_path, truecaser_fp):\\n bpe = BPE(glossaries=SPECIAL_TOKENS)\\n bpe.load(bpcodes_fp=bpe_int_fp, merges=-1)\\n\\n tcaser = MosesTruecaser(load_from=truecaser_fp, is_asr=True)\\n tcase_func = partial(tcaser.truecase, return_str=True, use_known=True)\\n unsup_tok_func = lambda x: bpe.tokenize(tcase_func(x).split())\\n\\n # PIPELINES AND VOCAB #\\n\\n vocab_pipeline = assemble_vocab_pipeline(text_fname=InpDataF.REV_TEXT,\\n lowercase=False,\\n tok_func=unsup_tok_func)\\n subword_vocab = Vocabulary(vocab_pipeline, name_prefix=\\\"word\\\",\\n special_tokens=SPECIAL_TOKENS)\\n subword_vocab.create(data_source={\\\"data_path\\\": data_path}, max_size=None,\\n data_fnames=InpDataF.REV_TEXT)\\n subword_vocab.write(bpe_vocab_fp, sep=' ')\",\n \"def __init__(self):\\n self.sess = tf.Session()\\n vocab_path = os.path.join(params.data_dir, \\\"vocab%d\\\" % params.vocab_size)\\n self.vocab, self.rev_vocab = data_utils.initialize_vocabulary(vocab_path)\\n self.model = model_utils.create_model(self.sess, True)\\n self.model.batch_size = 1 # Respond 1 sentence at a time.\",\n \"def get_vocab(which_vocab):\\n path = os.path.join(mg.WORKING_PATH, 'vocab', ''.join([which_vocab, '.json'\\n ]))\\n if os.path.exists(path):\\n with open(path, 'r') as js:\\n return(json.load(js))\\n else:\\n return(dict())\",\n \"def ensure_vocabulary(name):\\n vocab = read_vocabulary_by_name(name)\\n if vocab is None:\\n return create_vocabulary(name)\\n return vocab['id']\",\n \"def make_corpus(self, t, v=None):\\n v = self.vectorizer\\n\\n try:\\n corpus = v.transform(t)\\n except ValueError, e:\\n return None, None\\n \\n vocab = {y:x for x,y in v.vocabulary_.iteritems()}\\n corpus = gensim.matutils.Sparse2Corpus(corpus, documents_columns=False)\\n return corpus, vocab\",\n \"def load_vocabulary(self):\\n vocab_file = open(vocabulary_path, \\\"r\\\")\\n self.vocab_list = vocab_file.read().split(\\\"\\\\n\\\")\\n vocab_file.close()\\n print(\\\"[INFO] Reading vocabulary...\\\")\\n print(self.vocab_list[0:15])\",\n \"def build_vocab(data):\\n # data = _read_words(filename)\\n counter = collections.Counter(data)\\n # print('counter', counter) # dictionary for the occurrence number of each word, e.g. 'banknote': 1, 'photography': 1, 'kia': 1\\n count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))\\n # print('count_pairs',count_pairs) # convert dictionary to list of tuple, e.g. ('ssangyong', 1), ('swapo', 1), ('wachter', 1)\\n words, _ = list(zip(*count_pairs))\\n word_to_id = dict(zip(words, range(len(words))))\\n # print(words) # list of words\\n # print(word_to_id) # dictionary for word to id, e.g. 'campbell': 2587, 'atlantic': 2247, 'aoun': 6746\\n return word_to_id\",\n \"def create_vocabs(self):\\r\\n print('Creating vocabs...')\\r\\n\\r\\n # Update surface_char2id\\r\\n unique_surfaces = set(chain(*[sentence.surface_words for sentence in self.sentences]))\\r\\n unique_chars = set(chain(*[surface for surface in unique_surfaces]))\\r\\n for ch in unique_chars:\\r\\n self.surface_char2id[ch] = len(self.surface_char2id)\\r\\n\\r\\n # Update lemma_char2id\\r\\n unique_lemmas = set(chain(*[sentence.lemmas for sentence in self.sentences]))\\r\\n unique_chars = set(chain(*[lemma for lemma in unique_lemmas]))\\r\\n for ch in unique_chars:\\r\\n self.lemma_char2id[ch] = len(self.lemma_char2id)\\r\\n\\r\\n # Update transformation2id\\r\\n for sentence in self.sentences:\\r\\n for transformation in sentence.transformations:\\r\\n for _t in transformation:\\r\\n if _t not in self.transformation2id:\\r\\n self.transformation2id[_t] = len(self.transformation2id)\\r\\n\\r\\n # Update morph_tag2id\\r\\n unique_morph_tags = list(chain(*[sentence.morph_tags for sentence in self.sentences]))\\r\\n unique_tags = set(chain(*[morph_tag for morph_tag in unique_morph_tags]))\\r\\n for tag in unique_tags:\\r\\n self.morph_tag2id[tag] = len(self.morph_tag2id)\\r\\n print('Surface Chars={}, Lemma Chars={}, Transformations={}, tags={}'.format(\\r\\n len(self.surface_char2id), len(self.lemma_char2id), len(self.transformation2id), len(self.morph_tag2id)\\r\\n ))\",\n \"def create_choice(question, choice_text, votes=0):\\n return question.choice_set.create(choice_text=choice_text, votes=votes)\",\n \"def _init_vocab(self):\\n self._word2idx = {}\\n self._idx2word = {}\\n self.freqs = {}\\n self.vocab_size = 0\\n\\n self._add_word(self.pad_word)\\n self._add_word(self.start_word)\\n self._add_word(self.end_word)\\n self._add_word(self.unk_word)\\n\\n self.start_word_idx = self.stoi(self.start_word)\\n self.end_word_idx = self.stoi(self.end_word)\\n self.unk_word_idx = self.stoi(self.unk_word)\\n self.pad_word_idx = self.stoi(self.pad_word)\\n\\n self._special_tokens = {\\n 'bos_token': self.start_word,\\n 'cls_token': self.start_word,\\n 'eos_token': self.end_word,\\n 'sep_token': self.end_word,\\n 'pad_token': self.pad_word,\\n 'unk_token': self.unk_word,\\n }\\n\\n self._special_ids = {\\n 'bos_token_id': self.start_word_idx,\\n 'cls_token_id': self.start_word_idx,\\n 'eos_token_id': self.end_word_idx,\\n 'sep_token_id': self.end_word_idx,\\n 'pad_token_id': self.pad_word_idx,\\n 'unk_token_id': self.unk_word_idx,\\n }\\n\\n self.cls_token_id = self.bos_token_id = self.start_word_idx\\n self.eos_token_id = self.sep_token_id = self.end_word_idx\\n self.pad_token_id = self.pad_word_idx\\n self.unk_token_id = self.unk_word_idx\\n\\n self.cls_token = self.bos_token = self.start_word\\n self.eos_token = self.sep_token = self.end_word\\n self.pad_token = self.pad_word\\n self.unk_token = self.unk_word\",\n \"def __repr__(self):\\n l1 = \\\", \\\".join(\\\"{}={}\\\".format(x,y) for x,y in self._loading_params.items())\\n l2 = \\\"max_vocab_size={}, min_token_freq={}, max_token_freq={}, ngrams={}\\\".format(\\n self._max_vocab_size if hasattr(self, \\\"_max_vocab_size\\\") else None,\\n self._min_token_freq if hasattr(self, \\\"_min_token_freq\\\") else 0,\\n self._max_token_freq if hasattr(self, \\\"_max_token_freq\\\") else None,\\n self._ngrams if hasattr(self, \\\"_ngrams\\\") else [1,1]\\n )\\n desc = \\\"Vocabulary({}, {})\\\".format(l1, l2)\\n return desc\",\n \"def __init__(\\n self, values: Set, name: str, namespace: Optional[str] = None,\\n label: Optional[str] = None, description: Optional[str] = None\\n ):\\n super(VocabularyHandle, self).__init__(\\n name=name,\\n namespace=namespace,\\n label=label,\\n description=description\\n )\\n self.values = values\",\n \"def save_vocabulary(path, vocab):\\n print('saving vocabulary..')\\n with open(path, 'wb') as handle:\\n pickle.dump(vocab, handle, protocol=pickle.HIGHEST_PROTOCOL)\\n print('vocabulary was saved successfully!')\",\n \"def create_vocab(vocab_size):\\n vocab_dict = tff.simulation.datasets.stackoverflow.load_word_counts(\\n cache_dir='/tmp')\\n return list(vocab_dict.keys())[:vocab_size]\",\n \"def build_vocab(path, fname):\\r\\n\\twords = open(path, 'r', encoding='utf-8').read().split()\\r\\n\\twordCount = Counter(words)\\r\\n\\tif not os.path.exists(pm.vocab_path):\\r\\n\\t\\tos.makedirs(pm.vocab_path)\\r\\n\\twith open(pm.vocab_path + fname, 'w', encoding='utf-8') as f:\\r\\n\\t\\tf.write(\\\"{}\\\\t1000000000\\\\n{}\\\\t1000000000\\\\n{}\\\\t1000000000\\\\n{}\\\\t1000000000\\\\n\\\".format(\\\"<PAD>\\\", \\\"<UNK>\\\", \\\"<SOS>\\\", \\\"<EOS>\\\"))\\r\\n\\t\\tfor word, count in wordCount.most_common(len(wordCount)):\\r\\n\\t\\t\\tf.write(u\\\"{}\\\\t{}\\\\n\\\".format(word, count))\",\n \"def generate_vocab():\\n\\n vocab_dict = {}\\n folder_path = os.listdir(args.f)\\n for subfolder in folder_path:\\n subfolder_path = os.path.join(args.f, subfolder)\\n for filename in os.listdir(subfolder_path):\\n with open(os.path.join(subfolder_path, filename), 'r') as file:\\n read_file = file.read()\\n normalised_text = re.sub(r\\\"[^\\\\s\\\\w]\\\", \\\" \\\", read_file.lower())\\n vocab = normalised_text.split() #.split() creates a list of strings\\n vocab_dict.update({i: 0 for i in vocab})\\n return vocab_dict\",\n \"def load_vocab(path, encoding=\\\"UTF-9\\\"):\\n vocab = []\\n\\n if not os.path.exists(path):\\n return vocab\\n\\n with open(path, encoding=encoding) as fin:\\n for line in fin.readlines():\\n line = line.strip()\\n word, freq = line.split(\\\"\\\\t\\\")\\n vocab.append((word,int(freq)))\\n\\n return vocab\",\n \"def build_vocab(self, sentences, keep_raw_vocab=False, trim_rule=None, progress_per=10000, update=False):\\n print(\\\"build------------------\\\")\\n self.scan_vocab(sentences, progress_per=progress_per, trim_rule=trim_rule) # initial survey\\n # trim by min_count & precalculate downsampling\\n self.scale_vocab(trim_rule=trim_rule, update=update)\\n self.finalize_vocab(update=update)\",\n \"def from_dataset(cls, dataset, col_names, vocab_size, character_coverage, model_type, params):\\n\\n vocab = SentencePieceVocab()\\n root = copy.deepcopy(dataset).build_sentencepiece_vocab(vocab, col_names, vocab_size, character_coverage,\\n model_type, params)\\n for d in root.create_dict_iterator(num_epochs=1):\\n if d is None:\\n raise ValueError(\\\"from_dataset should receive data other than None.\\\")\\n return vocab\",\n \"def get_vocabulary(self, vocid, lang=None):\\n\\n payload = {}\\n if lang is not None:\\n payload['lang'] = lang\\n req = requests.get(self.api_base + vocid + '/', params=payload)\\n if req.status_code == 404:\\n raise ValueError(req.text)\\n req.raise_for_status()\\n return req.json()\",\n \"def list(self, request, format=None):\\n queryset = Vocab.objects.all()\\n serializer = VocabSerializer(queryset, context={\\\"request\\\": request})\\n return Response(serializer.data)\",\n \"def build_vocab(captions, threshold=0):\\n\\n\\tcounter = Counter()\\n\\tfor caption in captions:\\n\\t\\ttokens = caption.lower().split('/') \\n\\t\\tcounter.update(tokens)\\n\\n\\n\\t# If the word frequency is less than 'threshold', then the word is discarded.\\n\\twords = [word for word, cnt in counter.items() if cnt >= threshold]\\n\\t# Creates a vocab wrapper and add some special tokens.\\n\\tvocab = Vocabulary()\\n\\tvocab.add_word('<pad>')\\n\\tvocab.add_word('<start>')\\n\\tvocab.add_word('<end>')\\n\\tvocab.add_word('<unk>')\\n\\n\\t# Adds the words to the vocabulary.\\n\\tfor i, word in enumerate(words):\\n\\t\\tvocab.add_word(word)\\n\\treturn vocab\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67872804","0.660514","0.6490391","0.6246055","0.6192233","0.61789507","0.6158393","0.613217","0.61019224","0.60960674","0.606695","0.6037764","0.6025569","0.59994584","0.59994584","0.5967367","0.5922967","0.59061986","0.58743894","0.58231103","0.5815941","0.5815354","0.5810426","0.5759699","0.57592255","0.57481694","0.57349885","0.5726076","0.5724806","0.57091016","0.56836206","0.56727535","0.56656533","0.5655575","0.56373805","0.5620854","0.5611739","0.55690795","0.5556263","0.5551625","0.5535476","0.54586774","0.54565084","0.545555","0.5444492","0.5444163","0.5442156","0.5433655","0.5396574","0.5395586","0.539448","0.53885674","0.5363615","0.53581876","0.53578436","0.5346128","0.53391033","0.53354496","0.5316495","0.5288133","0.52873045","0.52710426","0.526976","0.526976","0.5266856","0.5258536","0.5245212","0.52396846","0.52382874","0.5226467","0.5209122","0.5209122","0.5209122","0.5208433","0.5208367","0.520046","0.5182154","0.5168196","0.51552653","0.51517135","0.51512915","0.51256377","0.51094","0.51088154","0.51039046","0.50928116","0.5091421","0.50912714","0.5081315","0.50798154","0.50686955","0.50644106","0.50572306","0.5044631","0.5041498","0.50410867","0.50322527","0.5031752","0.5024196","0.5024069","0.5002711"],"string":"[\n \"0.67872804\",\n \"0.660514\",\n \"0.6490391\",\n \"0.6246055\",\n \"0.6192233\",\n \"0.61789507\",\n \"0.6158393\",\n \"0.613217\",\n \"0.61019224\",\n \"0.60960674\",\n \"0.606695\",\n \"0.6037764\",\n \"0.6025569\",\n \"0.59994584\",\n \"0.59994584\",\n \"0.5967367\",\n \"0.5922967\",\n \"0.59061986\",\n \"0.58743894\",\n \"0.58231103\",\n \"0.5815941\",\n \"0.5815354\",\n \"0.5810426\",\n \"0.5759699\",\n \"0.57592255\",\n \"0.57481694\",\n \"0.57349885\",\n \"0.5726076\",\n \"0.5724806\",\n \"0.57091016\",\n \"0.56836206\",\n \"0.56727535\",\n \"0.56656533\",\n \"0.5655575\",\n \"0.56373805\",\n \"0.5620854\",\n \"0.5611739\",\n \"0.55690795\",\n \"0.5556263\",\n \"0.5551625\",\n \"0.5535476\",\n \"0.54586774\",\n \"0.54565084\",\n \"0.545555\",\n \"0.5444492\",\n \"0.5444163\",\n \"0.5442156\",\n \"0.5433655\",\n \"0.5396574\",\n \"0.5395586\",\n \"0.539448\",\n \"0.53885674\",\n \"0.5363615\",\n \"0.53581876\",\n \"0.53578436\",\n \"0.5346128\",\n \"0.53391033\",\n \"0.53354496\",\n \"0.5316495\",\n \"0.5288133\",\n \"0.52873045\",\n \"0.52710426\",\n \"0.526976\",\n \"0.526976\",\n \"0.5266856\",\n \"0.5258536\",\n \"0.5245212\",\n \"0.52396846\",\n \"0.52382874\",\n \"0.5226467\",\n \"0.5209122\",\n \"0.5209122\",\n \"0.5209122\",\n \"0.5208433\",\n \"0.5208367\",\n \"0.520046\",\n \"0.5182154\",\n \"0.5168196\",\n \"0.51552653\",\n \"0.51517135\",\n \"0.51512915\",\n \"0.51256377\",\n \"0.51094\",\n \"0.51088154\",\n \"0.51039046\",\n \"0.50928116\",\n \"0.5091421\",\n \"0.50912714\",\n \"0.5081315\",\n \"0.50798154\",\n \"0.50686955\",\n \"0.50644106\",\n \"0.50572306\",\n \"0.5044631\",\n \"0.5041498\",\n \"0.50410867\",\n \"0.50322527\",\n \"0.5031752\",\n \"0.5024196\",\n \"0.5024069\",\n \"0.5002711\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7381,"cells":{"query":{"kind":"string","value":"Add token to vocabulary."},"document":{"kind":"string","value":"def add_token(self, token):\n token = self.process_token(token)\n self._token_count.update([token])"},"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_token(self,token):\n\t\tif not token:\n\t\t\tlogging.error(\"Token cannot be empty!\")\n\t\t\texit()\n\n\t\tself.tokens.append(token.lower())\n\t\t#self.user_defined_token = token.lower()","def add_embedding(self, token, embedding):\n self.word2idx[token] = self.vocab_size\n self.vocab_size += 1\n\n self.embedding = np.vstack((self.embedding, embedding))","def add_vocab_word(self, word):\n # If it's a special token, it'll be separatelly processed during saving file. Skip here.\n if word in special_tokens:\n return\n # Check each character in the word. We don't want none-character (control code) in the vocaburary.\n for char in word:\n if cu.is_none_char(char):\n return\n # If it's a new word, store it.\n if (not word in self.words_ext) and (not word in self.words_new):\n self.words_new.append(word)","def AddToken(self, token, merge=False):\n token.SetLangId(self.id_)\n if not merge:\n self.tokens_.append(token)\n else:\n exists = self.MatchToken(token)\n if exists is None:\n self.tokens_.append(token)\n else:\n exists.IncrementCount(token.Count())","def __setitem__(self, word):\n raise ValueError(\"Vocabulary is only readable, if you want to set new k-v pair, use vocab.add()\")","def add_doc_to_vocab(filename, vocab):\n doc = load_doc(filename)\n tokens = clean_doc(doc)\n vocab.update(tokens)","def add_doc_to_vocab(filename, vocab):\n doc = load_doc(filename)\n tokens = clean_doc(doc)\n vocab.update(tokens)","def add(self, tokens):\n\n for token in tokens:\n self.vocab.add(token)\n\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\n if leader not in self.frequencies:\n self.frequencies[leader] = Frequency()\n\n self.frequencies[leader].add(token)","def add_token(\r\n self,\r\n ind: int,\r\n w: str,\r\n ) -> AddToken:\r\n self.t = self.t + 1\r\n content = self._encrypt_update(self.t, Op.ADD, ind, w)\r\n return self.sigma.add_token(content, w)","def add_word(self, word, freq=None):\n pass","def addToken(self, token: Token, offset: int):\n self.__tokens.append(token)\n self.__tokenMap[token] = offset","def addKeyWord(self, kWord):\n #kWord.printKeyWord()\n self.sentence.append(kWord)","def add(self, document):\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\n if not token.isalpha():\n continue\n\n if token in self.stopwords:\n continue\n \n if self.stemmer:\n token = self.stemmer.stem(token)\n \n if self.__unique_id not in self.index[token]:\n self.index[token].append(self.__unique_id)\n \n self.documents[self.__unique_id] = document\n self.__unique_id += 1","def _add_word(self, word):\n if not word in self._word2idx.keys():\n self._word2idx[word] = self.vocab_size\n self.freqs[word] = 0\n self._idx2word[self.vocab_size] = word\n self.vocab_size += 1\n self.freqs[word] += 1","def register_vocab(self, start_concept, end_concept, alias_of, regex_str):\n self.register_vocabulary(start_concept, end_concept,\n alias_of, regex_str)","def add_word_tag(self, token, label):\n # Add total count for label\n self.label_counts[label] += 1\n # Add count for word given label\n if token not in self.words_labels_counts[label]:\n self.words_labels_counts[label][token] = 1\n else:\n self.words_labels_counts[label][token] += 1","def addToken(self, tokenType, value):\r\n\t\tself.tokens.append( Token(tokenType, value) )","def add_word(self):\n word = self.word # easier to call word now\n\n wordlist_path = self.get_wordlist_path()\n with open(wordlist_path) as f:\n data = json.load(f)\n\n if exists_already(data,word):\n exit()\n\n next_index = int(data[\"cur_index\"]) + 1 # new index\n data[\"words\"][next_index] = word # update wordlist\n data[\"words\"] = dict(sorted(data[\"words\"].items(), key=lambda item: item[1])) # alphabetisize\n data[\"cur_index\"] = next_index # update index\n\n with open(wordlist_path, 'w') as f:\n json.dump(data, f, indent = 4)\n\n print(f\"[{word}] added to [{self.pos}]. This is the [{next_index}] indexed word added.\")","def add(self, token_docid):\n token = token_docid[0]\n doc_id = token_docid[1]\n # collapse identical tokens together\n if token in self.posting:\n self.posting[token].append(doc_id)\n else:\n self.posting[token] = [doc_id]","def add(self, token):\n self.rpc.call(MsfRpcMethod.AuthTokenAdd, [token])","def add_to_dict(self, tokens):\n# TODO: ?add normalization of a token?\n for token in tokens:\n if self.embedding_words and (token not in self.embedding_words):\n continue\n self.freq[token] += 1\n if token not in self.tok2ind:\n index = len(self.tok2ind)\n self.tok2ind[token] = index\n self.ind2tok[index] = token","def add_word(self, word, vector=None, low=-2., high=2.):\n if word not in self.w2v_idx:\n self.w2v_idx[word] = len(self.w2v_idx)\n if vector is None:\n vector = np.random.uniform(low=low, high=high, size=(self.w2v_dim,))\n self.w2v_out.append(np.asarray(vector, dtype=np.float32))\n else:\n print(\"word %s already in this word2vec\" % word)","def add_vocab_words(self, words):\n for word in words:\n word = word.strip()\n if word:\n self.add_vocab_word(word)","def update_vocab(self, word):\n \n if (word not in self.vocab and\n word in self.model.vocab and \n word not in [x.name for x in self.field]):\n \n self.vocab[word] = Vocab(index=self.vocab_size)\n self.vocab_size += 1","def _add_non_empty_token(self, token: str):\n if token != \"\":\n self._tokens.append(token)","def addWord(self, word):\n if word:\n self.word_dict[len(word)].append(word)","def _insert_vocab(self, json_obj, mode=InsertVocabMode.ALL):\n raise NotImplementedError","def push_token(self, tok):\n self.tokens.appendleft(tok)","def add(self, word):\r\n if not word or word.strip() == '':\r\n return\r\n self.words.append(word)","def visit(self, token: tokenize.TokenInfo) -> None:\n self._lines[token.start[0]].append(token)","def visit(self, token: tokenize.TokenInfo) -> None:\n self._lines[token.start[0]].append(token)","def add_word(self, word, data=None):\n self.__word = word\n self.__data = data","def token(self, token):\n\n self._token = token","def token(self, token):\n\n self._token = token","def next_word(self):\n self.append = self.add_new_word","def add_word(self, word):\n word = word.lower()\n if word in self.word_list:\n self.word_list[word] += 1\n else:\n self.word_list[word] = 1","def add_word(self, word):\n if word not in self.word2index:\n self.word2index[word] = self.n_words\n self.word2count[word] = 1\n self.index2word[self.n_words] = word\n self.n_words += 1\n else:\n self.word2count[word] += 1","def add_word(self, word):\n if word not in self.word2index:\n self.word2index[word] = self.n_words\n self.word2count[word] = 1\n self.index2word[self.n_words] = word\n self.n_words += 1\n else:\n self.word2count[word] += 1","def add_token(self, symbol): # type: (Union[BuiltinTypeSymbol, VarSymbol])-> None\n\n self._symbols[symbol.name] = symbol","def add(self, word: str) -> None:\n self.d.add(word)","def index_word(self, token):\n if token not in self.word_2_idx:\n idx = len(self.word_2_idx)\n self.word_2_idx[token] = idx\n self.idx_2_word[idx] = token","def put_vector(self, term, vector):\n self.terms.append(term)\n self.vectors.append(vector.vector)\n self.real_vectors.append(vector)\n return self.dict.update({term: vector})","def add_word(self, word):\r\n word = word.strip().lower()\r\n if word in self.builtin_words:\r\n return\r\n if word not in self.word_count:\r\n self.word_count[word] = 1\r\n else:\r\n self.word_count[word] += 1","def add(self, word: str) -> None:\n self.d.add(word)\n self.d.add(word.lower())\n self.save_user_dict()","def add_special_tokens_(model, tokenizer):\n orig_num_tokens = len(tokenizer.encoder)\n num_added_tokens = tokenizer.add_special_tokens(ATTR_TO_SPECIAL_TOKEN) # doesn't add if they are already there\n if num_added_tokens > 0:\n model.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)","def addWord(self, word: str) -> None:\n self.dict[len(word)].append(word)","def setVocabulary(self, vocabulary): # real signature unknown; restored from __doc__\n pass","def add_token(self, amount):\n self.M += amount","def add(self, word: str) -> None:\n self.words.add(word)\n self.added_words.add(word)","def update_from_vocabulary(self, vocab_path):\n with open(vocab_path, 'r') as vocab_file:\n for word in vocab_file:\n word = word.strip()\n self._add_new_word(word)","def addWord(self, word):\n current_node = self\n for idx, letter in enumerate(word):\n if letter not in current_node.kids:\n current_node.kids[letter] = WordDictionary()\n current_node.kids[letter].val = letter\n current_node = current_node.kids[letter]\n if idx == len(word) - 1:\n current_node.isWord = True","def add_word(self, word):\n\n if word in self.wordlist:\n return \"Already in word list\"\n\n file_name = self.config_folder + self.wordlist_file\n word_list = open(file_name,'a+')\n word_list.write(word + \"\\n\")\n word_list.close()\n return None","def add_word(self, word):\n word = self.map_word(word)\n super(InvariantLanguage, self).add_word(word)","def addWord(self, word: str) -> None:\n self.trie.insert(word)","def _add_token(self, token_type: TokenType, literal: Any = None):\n text = self.source[self.start : self.current]\n\n self.tokens.append(\n Token(token_type=token_type, lexeme=text, literal=literal, line=self.line)\n )","def add_unknown_token(self):\n self.load_all()\n sample_idxs = np.random.randint(0, self.embedding.shape[0],\n self.config.embedding_sample_size)\n unknown_vector = np.mean(self.embedding[sample_idxs, :], axis=0)\n\n self.add_embedding(self.config.unknown_token, unknown_vector)\n self.write_all()","def addWord(self, word: str) -> None:\n tmp = self.root\n for i, letter in enumerate(word):\n if letter not in tmp.seq:\n tmp.seq[letter] = Node()\n \n tmp = tmp.seq[letter]\n \n tmp.value = word","def token_vector(self, token):\n unit_id = self.svecs.vocab.unit2id(token.text)\n return self.svecs.emb[unit_id]","def addWord(self, word):\n lenw = len(word)\n if not lenw in self.bag:\n self.bag[lenw] = []\n self.bag[lenw].append(word)","def add_word_to_trigram(new_word):\n # Trigrams require 2 previous words\n # If we don't have those yet, then set them\n if len(prev_words) < 2:\n prev_words.append(new_word)\n return\n\n # If it exists, add the word to the list\n # If it doesn't exist, create it\n word_tuple = (prev_words[0], prev_words[1])\n if word_tuple in trigrams:\n trigrams[word_tuple].append(new_word)\n else:\n trigrams[word_tuple] = [new_word]\n\n # Increment the prev words\n prev_words.pop(0)\n prev_words.append(new_word)","def add(self, event: Event = None) -> None:\n if self.loaded:\n w = self.currentWord\n if w:\n self.spellController.add(w)\n self.tab.onFindButton()","def token(self, value):\r\n self._token = value","def add_sentence(self, sentence):\n cleaned = self.clean_string(sentence)\n stemmed = self.stem(cleaned)\n self.texts.append(stemmed)","def addWord(self, word):\n selected_node = self.root\n for i in word:\n if selected_node.next.get(i) is None:\n new_node = WordDictionary.Node()\n selected_node.next[i] = new_node\n selected_node = new_node\n else:\n selected_node = selected_node.next[i]\n if not selected_node.isFinish:\n selected_node.isFinish = True\n self.size += 1","def add(self, key, idx=None, count=1):\n key = self.lower_(key)\n if idx is not None:\n self.index2word[idx] = key\n self.word2index[key] = idx\n else:\n if key not in self.word2index:\n idx = len(self.word2index)\n self.index2word[idx] = key\n self.word2index[key] = idx\n\n if key not in self.word_count:\n self.word_count[key] = count\n else:\n self.word_count[key] += count","def add_word(self, request):\n if Word.query(Word.word == request.word).get():\n raise endpoints.ConflictException('That word is in the list!')\n else:\n word_list = []\n temp = request.word.upper()\n for i in temp:\n if i == \" \" or i < 'A' or i > 'Z':\n raise endpoints.BadRequestException(\n 'Please Enter One Word!')\n else:\n word_list.append(i)\n w = Word(word=request.word, word_list=word_list)\n w.put()\n return StringMessage(message='Added %s to the list!' % request.word)","def add(self, term, count=1):\n term = term.lower() if self.lower else term\n if term in self.term2id:\n idx = self.term2id[term]\n else:\n idx = len(self.id2term)\n self.id2term[idx] = term\n self.term2id[term] = idx\n if count > 0:\n if term in self.term_frequent:\n self.term_frequent[term] += count\n else:\n self.term_frequent[term] = count\n return idx","def add_tokens(self, tokens):\n self.result.extend([d for d in tokens])","def __iadd__(self, other):\n if isinstance(other, Token):\n new = Token(self.text + other.text, self.position, self.category)\n else:\n new = Token(self.text + other, self.position, self.category)\n return new","def add_tokens(self, sample):\n # Text\n inputs = self._tokenizer.encode_plus(sample['text'],\n add_special_tokens=True,\n max_length=self._max_text_length,\n padding='max_length', # TODO padding here or in model (together with item_glove)?\n truncation=True, # truncate to 512 (added for MSNBC dataset)\n return_attention_mask=True)\n # TODO warn if text was truncated\n #if len(TODO) > self._max_text_length:\n # self._logger.info(f'Truncate long input sentence ({len(TODO)} tokens) to {self._max_text_length}')\n sample['text_tokenized'] = inputs['input_ids']\n sample['text_attention_mask'] = inputs['attention_mask']\n # Item name (mention/surface form)\n inputs = self._tokenizer.encode(sample['item_name'],\n add_special_tokens=False)\n sample['item_name_tokenized'] = inputs","def add_language_model(self,lm):\n self.lm = lm\n try:\n self.vocab = get_vocab_from_ngram(lm.get_model())\n except:\n raise","def addWord(self, word): \n\n # make trie for new word\n self.root.makeTrie(word)","def add_word(self, pair, next_pair = None):\n if pair not in self:\n self.types += 1\n if next_pair:\n self[pair] = Dictogram([next_pair])\n elif next_pair:\n self[pair].add_count(next_pair)\n self.tokens += 1","def _add_new_word(self, word):\n if word not in self.word_to_id:\n word_id = len(self.word_to_id)\n self.word_to_id[word] = word_id\n self.id_to_word[word_id] = word","def add_vecs_to_vocab(vocab, vectors):\n length = len(vectors[0][1])\n vocab.reset_vectors(width=length)\n for word, vec in vectors:\n vocab.set_vector(word, vector=vec)\n return vocab","def token_to_alias(raw_text, vocab):\n pass","def add(self, term, count=1):\n term = term.lower() if self.lower else term\n if term in self.term2id:\n idx = self.term2id[term]\n else:\n idx = len(self.id2term)\n self.id2term[idx] = term\n self.term2id[term] = idx\n if count > 0:\n if term in self.term_frequent:\n self.term_frequent[term] += count\n else:\n self.term_frequent[term] = count\n\n if term not in self.initial_terms:\n for char in term:\n if char not in self.char2id.keys():\n idc = len(self.id2char)\n self.id2char[idc] = char\n self.char2id[char] = idc\n return idx","def add(self, term):\n self._value = self.accum_param.addInPlace(self._value, term)","def register_vocabulary(self, entity_value, entity_type,\n alias_of, regex_str):\n with self.lock:\n if regex_str:\n self.engine.register_regex_entity(regex_str)\n else:\n self.engine.register_entity(\n entity_value, entity_type, alias_of=alias_of)","def addWord(self, word):\n trie = self.trie\n for c in word:\n if c in trie.children:\n trie = trie.children[c]\n else:\n new_trie_node = TrieNode()\n trie.children[c] = new_trie_node\n trie = new_trie_node\n\n trie.is_term = True","def addWord(self, word):\n cur = self.__root\n for c in word:\n if c not in cur.next:\n cur.next[c] = Node()\n cur = cur.next[c]\n\n if not cur.isWord:\n cur.isWord = True","def create_vocabulary_single_token(\n data: Series,\n num_most_frequent: Optional[int] = None,\n processor: DataFrameEngine = PANDAS,\n unknown_symbol: str = UNKNOWN_SYMBOL,\n):\n processed_counts = data.str.strip().value_counts(sort=True)\n processed_counts = processor.compute(processed_counts)\n full_vocab = processed_counts.index.tolist()\n # Only add unknown symbol if num most frequent tokens is less than total number of unique tokens\n if num_most_frequent < len(full_vocab):\n vocab = [unknown_symbol] + full_vocab[:num_most_frequent]\n else:\n vocab = full_vocab\n str2idx = {unit: i for i, unit in enumerate(vocab)}\n str2freq = processed_counts.to_dict()\n str2freq = {k: str2freq.get(k, 0) for k in vocab}\n return vocab, str2idx, str2freq","def _look_up(self, token):\n if self.args.add_vn:\n return tf.nn.embedding_lookup(self.embedding_matrix + \\\n tf.random.normal(tf.shape(self.embedding_matrix), stddev=0.075), token)\n\n return tf.nn.embedding_lookup(self.embedding_matrix, token)","def add_special_tokens_(model, tokenizer, update_model=True):\n orig_num_tokens = len(tokenizer)\n num_added_tokens = tokenizer.add_special_tokens(ATTR_TO_SPECIAL_TOKEN) # doesn't add if they are already there\n #print(\"coab::\",len(tokenizer.vocab))\n if (num_added_tokens > 0 and update_model):\n model.encoder.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\n model.decoder.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\n #print(model.encoder.embeddings.word_embeddings.weight.shape)\n #print(model.decoder.bert.embeddings.word_embeddings.weight.shape)","def write_vocab(vocab, filename):\n print(\"Writing vocab...\")\n with open(filename, \"w\", encoding='utf-8') as f:\n for i, word in enumerate(vocab):\n if i != len(vocab) - 1:\n f.write(\"{}\\n\".format(word))\n else:\n f.write(word)\n print(\"- done. {} tokens\".format(len(vocab)))","def addtoken(name, unsafe_import_token):\n stm = shared_morphene_instance()\n if mph.rpc is not None:\n mph.rpc.rpcconnect()\n if not unlock_wallet(stm):\n return\n if not unsafe_import_token:\n unsafe_import_token = click.prompt(\"Enter private token\", confirmation_prompt=False, hide_input=True)\n mph.wallet.addToken(name, unsafe_import_token)\n set_shared_morphene_instance(stm)","def update_vocab(self, text):\n for char in text:\n if char not in self.vocab:\n self.vocab[char] = len(self.vocab)\n if char not in self.char2count:\n self.char2count[char] = 0\n self.char2count[char] += 1\n return","def __add__(self, other):\n if isinstance(other, Token):\n return Token(self.text + other.text, self.position, self.category)\n else:\n return Token(self.text + other, self.position, self.category)","def add_word(self, _set, document, label, word):\n \n if _set not in self.sets:\n self.sets[_set] = {}\n\n if document not in self.sets[_set]:\n self.sets[_set][document] = {}\n self.sets[_set][document]['label'] = label\n self.sets[_set][document]['words'] = set()\n self.sets[_set][document]['number_of_words'] = 0\n self.total_number_of_documents += 1\n self.sets[_set][document]['number_of_words'] += 1\n self.sets[_set][document]['words'].add(word)\n\n if word not in self.dictionary:\n self.dictionary[word] = {}\n self.dictionary[word]['id'] = len(self.dictionary)-1\n self.dictionary[word]['docs'] = {}\n\n if document not in self.dictionary[word]['docs']:\n self.dictionary[word]['docs'][document] = 1\n else:\n self.dictionary[word]['docs'][document] += 1","def addWord(self, word):\n node = self.root\n for ch in word:\n node = node.children[ch]\n node.isWord = True","def add_keyword(self, new_word):\n\n self.keywords.append(new_word)\n words = Keywords()\n words.add(new_word)\n mongo.db.users.update({\"name\": self.username},\n {\"$set\": {\"keywords\": self.keywords}})","def add_word_and_label_id(self, word, label_id):\n self.words.append(word)\n self.label_ids.append(label_id)","def add_words(self, words):\r\n for word in words:\r\n self.add(word)","async def wordfilter_add(self, ctx, *, phrase):\n phrase = phrase.lower()\n await self.bot.redis.rpush('wordfilter', phrase)\n self.words.append(phrase)\n await ctx.send(f'Added `{phrase}` to the filtered words')","def addWord(self, word):\n node = self\n for c in word:\n node = node[c]\n node.go += 1","def createToken(self,type,value):\n newToken = Token(type, value)\n self.tokensTable.append(newToken)","def add_word_to_dictionary(self, word: str):\n self.trie.add_word(word)","def addWord(self, word: str) -> None:\n if str(len(word)) in self.elements:\n self.elements[str(len(word))].add(word)\n else:\n self.elements[str(len(word))] = {word}","def add(self, sentence):\n self._sentences.add(sentence)"],"string":"[\n \"def add_token(self,token):\\n\\t\\tif not token:\\n\\t\\t\\tlogging.error(\\\"Token cannot be empty!\\\")\\n\\t\\t\\texit()\\n\\n\\t\\tself.tokens.append(token.lower())\\n\\t\\t#self.user_defined_token = token.lower()\",\n \"def add_embedding(self, token, embedding):\\n self.word2idx[token] = self.vocab_size\\n self.vocab_size += 1\\n\\n self.embedding = np.vstack((self.embedding, embedding))\",\n \"def add_vocab_word(self, word):\\n # If it's a special token, it'll be separatelly processed during saving file. Skip here.\\n if word in special_tokens:\\n return\\n # Check each character in the word. We don't want none-character (control code) in the vocaburary.\\n for char in word:\\n if cu.is_none_char(char):\\n return\\n # If it's a new word, store it.\\n if (not word in self.words_ext) and (not word in self.words_new):\\n self.words_new.append(word)\",\n \"def AddToken(self, token, merge=False):\\n token.SetLangId(self.id_)\\n if not merge:\\n self.tokens_.append(token)\\n else:\\n exists = self.MatchToken(token)\\n if exists is None:\\n self.tokens_.append(token)\\n else:\\n exists.IncrementCount(token.Count())\",\n \"def __setitem__(self, word):\\n raise ValueError(\\\"Vocabulary is only readable, if you want to set new k-v pair, use vocab.add()\\\")\",\n \"def add_doc_to_vocab(filename, vocab):\\n doc = load_doc(filename)\\n tokens = clean_doc(doc)\\n vocab.update(tokens)\",\n \"def add_doc_to_vocab(filename, vocab):\\n doc = load_doc(filename)\\n tokens = clean_doc(doc)\\n vocab.update(tokens)\",\n \"def add(self, tokens):\\n\\n for token in tokens:\\n self.vocab.add(token)\\n\\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\\n if leader not in self.frequencies:\\n self.frequencies[leader] = Frequency()\\n\\n self.frequencies[leader].add(token)\",\n \"def add_token(\\r\\n self,\\r\\n ind: int,\\r\\n w: str,\\r\\n ) -> AddToken:\\r\\n self.t = self.t + 1\\r\\n content = self._encrypt_update(self.t, Op.ADD, ind, w)\\r\\n return self.sigma.add_token(content, w)\",\n \"def add_word(self, word, freq=None):\\n pass\",\n \"def addToken(self, token: Token, offset: int):\\n self.__tokens.append(token)\\n self.__tokenMap[token] = offset\",\n \"def addKeyWord(self, kWord):\\n #kWord.printKeyWord()\\n self.sentence.append(kWord)\",\n \"def add(self, document):\\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\\n if not token.isalpha():\\n continue\\n\\n if token in self.stopwords:\\n continue\\n \\n if self.stemmer:\\n token = self.stemmer.stem(token)\\n \\n if self.__unique_id not in self.index[token]:\\n self.index[token].append(self.__unique_id)\\n \\n self.documents[self.__unique_id] = document\\n self.__unique_id += 1\",\n \"def _add_word(self, word):\\n if not word in self._word2idx.keys():\\n self._word2idx[word] = self.vocab_size\\n self.freqs[word] = 0\\n self._idx2word[self.vocab_size] = word\\n self.vocab_size += 1\\n self.freqs[word] += 1\",\n \"def register_vocab(self, start_concept, end_concept, alias_of, regex_str):\\n self.register_vocabulary(start_concept, end_concept,\\n alias_of, regex_str)\",\n \"def add_word_tag(self, token, label):\\n # Add total count for label\\n self.label_counts[label] += 1\\n # Add count for word given label\\n if token not in self.words_labels_counts[label]:\\n self.words_labels_counts[label][token] = 1\\n else:\\n self.words_labels_counts[label][token] += 1\",\n \"def addToken(self, tokenType, value):\\r\\n\\t\\tself.tokens.append( Token(tokenType, value) )\",\n \"def add_word(self):\\n word = self.word # easier to call word now\\n\\n wordlist_path = self.get_wordlist_path()\\n with open(wordlist_path) as f:\\n data = json.load(f)\\n\\n if exists_already(data,word):\\n exit()\\n\\n next_index = int(data[\\\"cur_index\\\"]) + 1 # new index\\n data[\\\"words\\\"][next_index] = word # update wordlist\\n data[\\\"words\\\"] = dict(sorted(data[\\\"words\\\"].items(), key=lambda item: item[1])) # alphabetisize\\n data[\\\"cur_index\\\"] = next_index # update index\\n\\n with open(wordlist_path, 'w') as f:\\n json.dump(data, f, indent = 4)\\n\\n print(f\\\"[{word}] added to [{self.pos}]. This is the [{next_index}] indexed word added.\\\")\",\n \"def add(self, token_docid):\\n token = token_docid[0]\\n doc_id = token_docid[1]\\n # collapse identical tokens together\\n if token in self.posting:\\n self.posting[token].append(doc_id)\\n else:\\n self.posting[token] = [doc_id]\",\n \"def add(self, token):\\n self.rpc.call(MsfRpcMethod.AuthTokenAdd, [token])\",\n \"def add_to_dict(self, tokens):\\n# TODO: ?add normalization of a token?\\n for token in tokens:\\n if self.embedding_words and (token not in self.embedding_words):\\n continue\\n self.freq[token] += 1\\n if token not in self.tok2ind:\\n index = len(self.tok2ind)\\n self.tok2ind[token] = index\\n self.ind2tok[index] = token\",\n \"def add_word(self, word, vector=None, low=-2., high=2.):\\n if word not in self.w2v_idx:\\n self.w2v_idx[word] = len(self.w2v_idx)\\n if vector is None:\\n vector = np.random.uniform(low=low, high=high, size=(self.w2v_dim,))\\n self.w2v_out.append(np.asarray(vector, dtype=np.float32))\\n else:\\n print(\\\"word %s already in this word2vec\\\" % word)\",\n \"def add_vocab_words(self, words):\\n for word in words:\\n word = word.strip()\\n if word:\\n self.add_vocab_word(word)\",\n \"def update_vocab(self, word):\\n \\n if (word not in self.vocab and\\n word in self.model.vocab and \\n word not in [x.name for x in self.field]):\\n \\n self.vocab[word] = Vocab(index=self.vocab_size)\\n self.vocab_size += 1\",\n \"def _add_non_empty_token(self, token: str):\\n if token != \\\"\\\":\\n self._tokens.append(token)\",\n \"def addWord(self, word):\\n if word:\\n self.word_dict[len(word)].append(word)\",\n \"def _insert_vocab(self, json_obj, mode=InsertVocabMode.ALL):\\n raise NotImplementedError\",\n \"def push_token(self, tok):\\n self.tokens.appendleft(tok)\",\n \"def add(self, word):\\r\\n if not word or word.strip() == '':\\r\\n return\\r\\n self.words.append(word)\",\n \"def visit(self, token: tokenize.TokenInfo) -> None:\\n self._lines[token.start[0]].append(token)\",\n \"def visit(self, token: tokenize.TokenInfo) -> None:\\n self._lines[token.start[0]].append(token)\",\n \"def add_word(self, word, data=None):\\n self.__word = word\\n self.__data = data\",\n \"def token(self, token):\\n\\n self._token = token\",\n \"def token(self, token):\\n\\n self._token = token\",\n \"def next_word(self):\\n self.append = self.add_new_word\",\n \"def add_word(self, word):\\n word = word.lower()\\n if word in self.word_list:\\n self.word_list[word] += 1\\n else:\\n self.word_list[word] = 1\",\n \"def add_word(self, word):\\n if word not in self.word2index:\\n self.word2index[word] = self.n_words\\n self.word2count[word] = 1\\n self.index2word[self.n_words] = word\\n self.n_words += 1\\n else:\\n self.word2count[word] += 1\",\n \"def add_word(self, word):\\n if word not in self.word2index:\\n self.word2index[word] = self.n_words\\n self.word2count[word] = 1\\n self.index2word[self.n_words] = word\\n self.n_words += 1\\n else:\\n self.word2count[word] += 1\",\n \"def add_token(self, symbol): # type: (Union[BuiltinTypeSymbol, VarSymbol])-> None\\n\\n self._symbols[symbol.name] = symbol\",\n \"def add(self, word: str) -> None:\\n self.d.add(word)\",\n \"def index_word(self, token):\\n if token not in self.word_2_idx:\\n idx = len(self.word_2_idx)\\n self.word_2_idx[token] = idx\\n self.idx_2_word[idx] = token\",\n \"def put_vector(self, term, vector):\\n self.terms.append(term)\\n self.vectors.append(vector.vector)\\n self.real_vectors.append(vector)\\n return self.dict.update({term: vector})\",\n \"def add_word(self, word):\\r\\n word = word.strip().lower()\\r\\n if word in self.builtin_words:\\r\\n return\\r\\n if word not in self.word_count:\\r\\n self.word_count[word] = 1\\r\\n else:\\r\\n self.word_count[word] += 1\",\n \"def add(self, word: str) -> None:\\n self.d.add(word)\\n self.d.add(word.lower())\\n self.save_user_dict()\",\n \"def add_special_tokens_(model, tokenizer):\\n orig_num_tokens = len(tokenizer.encoder)\\n num_added_tokens = tokenizer.add_special_tokens(ATTR_TO_SPECIAL_TOKEN) # doesn't add if they are already there\\n if num_added_tokens > 0:\\n model.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\",\n \"def addWord(self, word: str) -> None:\\n self.dict[len(word)].append(word)\",\n \"def setVocabulary(self, vocabulary): # real signature unknown; restored from __doc__\\n pass\",\n \"def add_token(self, amount):\\n self.M += amount\",\n \"def add(self, word: str) -> None:\\n self.words.add(word)\\n self.added_words.add(word)\",\n \"def update_from_vocabulary(self, vocab_path):\\n with open(vocab_path, 'r') as vocab_file:\\n for word in vocab_file:\\n word = word.strip()\\n self._add_new_word(word)\",\n \"def addWord(self, word):\\n current_node = self\\n for idx, letter in enumerate(word):\\n if letter not in current_node.kids:\\n current_node.kids[letter] = WordDictionary()\\n current_node.kids[letter].val = letter\\n current_node = current_node.kids[letter]\\n if idx == len(word) - 1:\\n current_node.isWord = True\",\n \"def add_word(self, word):\\n\\n if word in self.wordlist:\\n return \\\"Already in word list\\\"\\n\\n file_name = self.config_folder + self.wordlist_file\\n word_list = open(file_name,'a+')\\n word_list.write(word + \\\"\\\\n\\\")\\n word_list.close()\\n return None\",\n \"def add_word(self, word):\\n word = self.map_word(word)\\n super(InvariantLanguage, self).add_word(word)\",\n \"def addWord(self, word: str) -> None:\\n self.trie.insert(word)\",\n \"def _add_token(self, token_type: TokenType, literal: Any = None):\\n text = self.source[self.start : self.current]\\n\\n self.tokens.append(\\n Token(token_type=token_type, lexeme=text, literal=literal, line=self.line)\\n )\",\n \"def add_unknown_token(self):\\n self.load_all()\\n sample_idxs = np.random.randint(0, self.embedding.shape[0],\\n self.config.embedding_sample_size)\\n unknown_vector = np.mean(self.embedding[sample_idxs, :], axis=0)\\n\\n self.add_embedding(self.config.unknown_token, unknown_vector)\\n self.write_all()\",\n \"def addWord(self, word: str) -> None:\\n tmp = self.root\\n for i, letter in enumerate(word):\\n if letter not in tmp.seq:\\n tmp.seq[letter] = Node()\\n \\n tmp = tmp.seq[letter]\\n \\n tmp.value = word\",\n \"def token_vector(self, token):\\n unit_id = self.svecs.vocab.unit2id(token.text)\\n return self.svecs.emb[unit_id]\",\n \"def addWord(self, word):\\n lenw = len(word)\\n if not lenw in self.bag:\\n self.bag[lenw] = []\\n self.bag[lenw].append(word)\",\n \"def add_word_to_trigram(new_word):\\n # Trigrams require 2 previous words\\n # If we don't have those yet, then set them\\n if len(prev_words) < 2:\\n prev_words.append(new_word)\\n return\\n\\n # If it exists, add the word to the list\\n # If it doesn't exist, create it\\n word_tuple = (prev_words[0], prev_words[1])\\n if word_tuple in trigrams:\\n trigrams[word_tuple].append(new_word)\\n else:\\n trigrams[word_tuple] = [new_word]\\n\\n # Increment the prev words\\n prev_words.pop(0)\\n prev_words.append(new_word)\",\n \"def add(self, event: Event = None) -> None:\\n if self.loaded:\\n w = self.currentWord\\n if w:\\n self.spellController.add(w)\\n self.tab.onFindButton()\",\n \"def token(self, value):\\r\\n self._token = value\",\n \"def add_sentence(self, sentence):\\n cleaned = self.clean_string(sentence)\\n stemmed = self.stem(cleaned)\\n self.texts.append(stemmed)\",\n \"def addWord(self, word):\\n selected_node = self.root\\n for i in word:\\n if selected_node.next.get(i) is None:\\n new_node = WordDictionary.Node()\\n selected_node.next[i] = new_node\\n selected_node = new_node\\n else:\\n selected_node = selected_node.next[i]\\n if not selected_node.isFinish:\\n selected_node.isFinish = True\\n self.size += 1\",\n \"def add(self, key, idx=None, count=1):\\n key = self.lower_(key)\\n if idx is not None:\\n self.index2word[idx] = key\\n self.word2index[key] = idx\\n else:\\n if key not in self.word2index:\\n idx = len(self.word2index)\\n self.index2word[idx] = key\\n self.word2index[key] = idx\\n\\n if key not in self.word_count:\\n self.word_count[key] = count\\n else:\\n self.word_count[key] += count\",\n \"def add_word(self, request):\\n if Word.query(Word.word == request.word).get():\\n raise endpoints.ConflictException('That word is in the list!')\\n else:\\n word_list = []\\n temp = request.word.upper()\\n for i in temp:\\n if i == \\\" \\\" or i < 'A' or i > 'Z':\\n raise endpoints.BadRequestException(\\n 'Please Enter One Word!')\\n else:\\n word_list.append(i)\\n w = Word(word=request.word, word_list=word_list)\\n w.put()\\n return StringMessage(message='Added %s to the list!' % request.word)\",\n \"def add(self, term, count=1):\\n term = term.lower() if self.lower else term\\n if term in self.term2id:\\n idx = self.term2id[term]\\n else:\\n idx = len(self.id2term)\\n self.id2term[idx] = term\\n self.term2id[term] = idx\\n if count > 0:\\n if term in self.term_frequent:\\n self.term_frequent[term] += count\\n else:\\n self.term_frequent[term] = count\\n return idx\",\n \"def add_tokens(self, tokens):\\n self.result.extend([d for d in tokens])\",\n \"def __iadd__(self, other):\\n if isinstance(other, Token):\\n new = Token(self.text + other.text, self.position, self.category)\\n else:\\n new = Token(self.text + other, self.position, self.category)\\n return new\",\n \"def add_tokens(self, sample):\\n # Text\\n inputs = self._tokenizer.encode_plus(sample['text'],\\n add_special_tokens=True,\\n max_length=self._max_text_length,\\n padding='max_length', # TODO padding here or in model (together with item_glove)?\\n truncation=True, # truncate to 512 (added for MSNBC dataset)\\n return_attention_mask=True)\\n # TODO warn if text was truncated\\n #if len(TODO) > self._max_text_length:\\n # self._logger.info(f'Truncate long input sentence ({len(TODO)} tokens) to {self._max_text_length}')\\n sample['text_tokenized'] = inputs['input_ids']\\n sample['text_attention_mask'] = inputs['attention_mask']\\n # Item name (mention/surface form)\\n inputs = self._tokenizer.encode(sample['item_name'],\\n add_special_tokens=False)\\n sample['item_name_tokenized'] = inputs\",\n \"def add_language_model(self,lm):\\n self.lm = lm\\n try:\\n self.vocab = get_vocab_from_ngram(lm.get_model())\\n except:\\n raise\",\n \"def addWord(self, word): \\n\\n # make trie for new word\\n self.root.makeTrie(word)\",\n \"def add_word(self, pair, next_pair = None):\\n if pair not in self:\\n self.types += 1\\n if next_pair:\\n self[pair] = Dictogram([next_pair])\\n elif next_pair:\\n self[pair].add_count(next_pair)\\n self.tokens += 1\",\n \"def _add_new_word(self, word):\\n if word not in self.word_to_id:\\n word_id = len(self.word_to_id)\\n self.word_to_id[word] = word_id\\n self.id_to_word[word_id] = word\",\n \"def add_vecs_to_vocab(vocab, vectors):\\n length = len(vectors[0][1])\\n vocab.reset_vectors(width=length)\\n for word, vec in vectors:\\n vocab.set_vector(word, vector=vec)\\n return vocab\",\n \"def token_to_alias(raw_text, vocab):\\n pass\",\n \"def add(self, term, count=1):\\n term = term.lower() if self.lower else term\\n if term in self.term2id:\\n idx = self.term2id[term]\\n else:\\n idx = len(self.id2term)\\n self.id2term[idx] = term\\n self.term2id[term] = idx\\n if count > 0:\\n if term in self.term_frequent:\\n self.term_frequent[term] += count\\n else:\\n self.term_frequent[term] = count\\n\\n if term not in self.initial_terms:\\n for char in term:\\n if char not in self.char2id.keys():\\n idc = len(self.id2char)\\n self.id2char[idc] = char\\n self.char2id[char] = idc\\n return idx\",\n \"def add(self, term):\\n self._value = self.accum_param.addInPlace(self._value, term)\",\n \"def register_vocabulary(self, entity_value, entity_type,\\n alias_of, regex_str):\\n with self.lock:\\n if regex_str:\\n self.engine.register_regex_entity(regex_str)\\n else:\\n self.engine.register_entity(\\n entity_value, entity_type, alias_of=alias_of)\",\n \"def addWord(self, word):\\n trie = self.trie\\n for c in word:\\n if c in trie.children:\\n trie = trie.children[c]\\n else:\\n new_trie_node = TrieNode()\\n trie.children[c] = new_trie_node\\n trie = new_trie_node\\n\\n trie.is_term = True\",\n \"def addWord(self, word):\\n cur = self.__root\\n for c in word:\\n if c not in cur.next:\\n cur.next[c] = Node()\\n cur = cur.next[c]\\n\\n if not cur.isWord:\\n cur.isWord = True\",\n \"def create_vocabulary_single_token(\\n data: Series,\\n num_most_frequent: Optional[int] = None,\\n processor: DataFrameEngine = PANDAS,\\n unknown_symbol: str = UNKNOWN_SYMBOL,\\n):\\n processed_counts = data.str.strip().value_counts(sort=True)\\n processed_counts = processor.compute(processed_counts)\\n full_vocab = processed_counts.index.tolist()\\n # Only add unknown symbol if num most frequent tokens is less than total number of unique tokens\\n if num_most_frequent < len(full_vocab):\\n vocab = [unknown_symbol] + full_vocab[:num_most_frequent]\\n else:\\n vocab = full_vocab\\n str2idx = {unit: i for i, unit in enumerate(vocab)}\\n str2freq = processed_counts.to_dict()\\n str2freq = {k: str2freq.get(k, 0) for k in vocab}\\n return vocab, str2idx, str2freq\",\n \"def _look_up(self, token):\\n if self.args.add_vn:\\n return tf.nn.embedding_lookup(self.embedding_matrix + \\\\\\n tf.random.normal(tf.shape(self.embedding_matrix), stddev=0.075), token)\\n\\n return tf.nn.embedding_lookup(self.embedding_matrix, token)\",\n \"def add_special_tokens_(model, tokenizer, update_model=True):\\n orig_num_tokens = len(tokenizer)\\n num_added_tokens = tokenizer.add_special_tokens(ATTR_TO_SPECIAL_TOKEN) # doesn't add if they are already there\\n #print(\\\"coab::\\\",len(tokenizer.vocab))\\n if (num_added_tokens > 0 and update_model):\\n model.encoder.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\\n model.decoder.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\\n #print(model.encoder.embeddings.word_embeddings.weight.shape)\\n #print(model.decoder.bert.embeddings.word_embeddings.weight.shape)\",\n \"def write_vocab(vocab, filename):\\n print(\\\"Writing vocab...\\\")\\n with open(filename, \\\"w\\\", encoding='utf-8') as f:\\n for i, word in enumerate(vocab):\\n if i != len(vocab) - 1:\\n f.write(\\\"{}\\\\n\\\".format(word))\\n else:\\n f.write(word)\\n print(\\\"- done. {} tokens\\\".format(len(vocab)))\",\n \"def addtoken(name, unsafe_import_token):\\n stm = shared_morphene_instance()\\n if mph.rpc is not None:\\n mph.rpc.rpcconnect()\\n if not unlock_wallet(stm):\\n return\\n if not unsafe_import_token:\\n unsafe_import_token = click.prompt(\\\"Enter private token\\\", confirmation_prompt=False, hide_input=True)\\n mph.wallet.addToken(name, unsafe_import_token)\\n set_shared_morphene_instance(stm)\",\n \"def update_vocab(self, text):\\n for char in text:\\n if char not in self.vocab:\\n self.vocab[char] = len(self.vocab)\\n if char not in self.char2count:\\n self.char2count[char] = 0\\n self.char2count[char] += 1\\n return\",\n \"def __add__(self, other):\\n if isinstance(other, Token):\\n return Token(self.text + other.text, self.position, self.category)\\n else:\\n return Token(self.text + other, self.position, self.category)\",\n \"def add_word(self, _set, document, label, word):\\n \\n if _set not in self.sets:\\n self.sets[_set] = {}\\n\\n if document not in self.sets[_set]:\\n self.sets[_set][document] = {}\\n self.sets[_set][document]['label'] = label\\n self.sets[_set][document]['words'] = set()\\n self.sets[_set][document]['number_of_words'] = 0\\n self.total_number_of_documents += 1\\n self.sets[_set][document]['number_of_words'] += 1\\n self.sets[_set][document]['words'].add(word)\\n\\n if word not in self.dictionary:\\n self.dictionary[word] = {}\\n self.dictionary[word]['id'] = len(self.dictionary)-1\\n self.dictionary[word]['docs'] = {}\\n\\n if document not in self.dictionary[word]['docs']:\\n self.dictionary[word]['docs'][document] = 1\\n else:\\n self.dictionary[word]['docs'][document] += 1\",\n \"def addWord(self, word):\\n node = self.root\\n for ch in word:\\n node = node.children[ch]\\n node.isWord = True\",\n \"def add_keyword(self, new_word):\\n\\n self.keywords.append(new_word)\\n words = Keywords()\\n words.add(new_word)\\n mongo.db.users.update({\\\"name\\\": self.username},\\n {\\\"$set\\\": {\\\"keywords\\\": self.keywords}})\",\n \"def add_word_and_label_id(self, word, label_id):\\n self.words.append(word)\\n self.label_ids.append(label_id)\",\n \"def add_words(self, words):\\r\\n for word in words:\\r\\n self.add(word)\",\n \"async def wordfilter_add(self, ctx, *, phrase):\\n phrase = phrase.lower()\\n await self.bot.redis.rpush('wordfilter', phrase)\\n self.words.append(phrase)\\n await ctx.send(f'Added `{phrase}` to the filtered words')\",\n \"def addWord(self, word):\\n node = self\\n for c in word:\\n node = node[c]\\n node.go += 1\",\n \"def createToken(self,type,value):\\n newToken = Token(type, value)\\n self.tokensTable.append(newToken)\",\n \"def add_word_to_dictionary(self, word: str):\\n self.trie.add_word(word)\",\n \"def addWord(self, word: str) -> None:\\n if str(len(word)) in self.elements:\\n self.elements[str(len(word))].add(word)\\n else:\\n self.elements[str(len(word))] = {word}\",\n \"def add(self, sentence):\\n self._sentences.add(sentence)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7474371","0.7235822","0.6903988","0.6526929","0.65188766","0.6505907","0.6505907","0.64998305","0.6496983","0.6493279","0.64262176","0.6420701","0.6391367","0.6325264","0.63200015","0.62549394","0.62311953","0.622333","0.6177798","0.61690384","0.61336285","0.61031127","0.6096867","0.60905343","0.60826486","0.6082443","0.6053392","0.60310906","0.6017655","0.5985635","0.5985635","0.59685165","0.5918892","0.5918892","0.5906536","0.5901874","0.5886092","0.5886092","0.5881147","0.58716494","0.58709234","0.5863565","0.582057","0.5819288","0.58116066","0.5798947","0.5776732","0.5759984","0.575981","0.5750529","0.57484907","0.57032067","0.5700063","0.5692102","0.5655651","0.56532747","0.5646247","0.562467","0.5617013","0.5584298","0.5558455","0.5558237","0.5553753","0.5548334","0.5530405","0.55226505","0.55153143","0.55141014","0.54802996","0.5479846","0.54763407","0.54537123","0.5442956","0.5442045","0.5441605","0.5440332","0.54367423","0.54364043","0.542796","0.5426528","0.5426118","0.54260564","0.54036283","0.5402926","0.5395004","0.5394236","0.5393136","0.53918856","0.53917354","0.538835","0.5378691","0.53780437","0.53669053","0.5356126","0.53551996","0.53549474","0.53537476","0.53488505","0.5342317"],"string":"[\n \"0.7474371\",\n \"0.7235822\",\n \"0.6903988\",\n \"0.6526929\",\n \"0.65188766\",\n \"0.6505907\",\n \"0.6505907\",\n \"0.64998305\",\n \"0.6496983\",\n \"0.6493279\",\n \"0.64262176\",\n \"0.6420701\",\n \"0.6391367\",\n \"0.6325264\",\n \"0.63200015\",\n \"0.62549394\",\n \"0.62311953\",\n \"0.622333\",\n \"0.6177798\",\n \"0.61690384\",\n \"0.61336285\",\n \"0.61031127\",\n \"0.6096867\",\n \"0.60905343\",\n \"0.60826486\",\n \"0.6082443\",\n \"0.6053392\",\n \"0.60310906\",\n \"0.6017655\",\n \"0.5985635\",\n \"0.5985635\",\n \"0.59685165\",\n \"0.5918892\",\n \"0.5918892\",\n \"0.5906536\",\n \"0.5901874\",\n \"0.5886092\",\n \"0.5886092\",\n \"0.5881147\",\n \"0.58716494\",\n \"0.58709234\",\n \"0.5863565\",\n \"0.582057\",\n \"0.5819288\",\n \"0.58116066\",\n \"0.5798947\",\n \"0.5776732\",\n \"0.5759984\",\n \"0.575981\",\n \"0.5750529\",\n \"0.57484907\",\n \"0.57032067\",\n \"0.5700063\",\n \"0.5692102\",\n \"0.5655651\",\n \"0.56532747\",\n \"0.5646247\",\n \"0.562467\",\n \"0.5617013\",\n \"0.5584298\",\n \"0.5558455\",\n \"0.5558237\",\n \"0.5553753\",\n \"0.5548334\",\n \"0.5530405\",\n \"0.55226505\",\n \"0.55153143\",\n \"0.55141014\",\n \"0.54802996\",\n \"0.5479846\",\n \"0.54763407\",\n \"0.54537123\",\n \"0.5442956\",\n \"0.5442045\",\n \"0.5441605\",\n \"0.5440332\",\n \"0.54367423\",\n \"0.54364043\",\n \"0.542796\",\n \"0.5426528\",\n \"0.5426118\",\n \"0.54260564\",\n \"0.54036283\",\n \"0.5402926\",\n \"0.5395004\",\n \"0.5394236\",\n \"0.5393136\",\n \"0.53918856\",\n \"0.53917354\",\n \"0.538835\",\n \"0.5378691\",\n \"0.53780437\",\n \"0.53669053\",\n \"0.5356126\",\n \"0.53551996\",\n \"0.53549474\",\n \"0.53537476\",\n \"0.53488505\",\n \"0.5342317\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68879795"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":7382,"cells":{"query":{"kind":"string","value":"Update dictionary from a collection of documents. Each document is a list of tokens."},"document":{"kind":"string","value":"def add_documents(self, docs):\n if 'sentences' in docs:\n for sent in docs.sentences:\n sent = map(self.process_token, [t for t in sent.tokens if not t.is_stopword])\n self._token_count.update(sent)\n\n else:\n sent = list(map(self.process_token, [t for t in docs.tokens if not t.is_stopword]))\n self._token_count.update(sent)"},"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_documents(self, docs):\n for sent in docs:\n sent = map(self.process_token, sent)\n self._token_count.update(sent)","def add_document_lists(self, docs):\n for sent in docs:\n sent = map(self.process_token, sent)\n self._token_count.update(sent)","def add_to_dict(self, tokens):\n# TODO: ?add normalization of a token?\n for token in tokens:\n if self.embedding_words and (token not in self.embedding_words):\n continue\n self.freq[token] += 1\n if token not in self.tok2ind:\n index = len(self.tok2ind)\n self.tok2ind[token] = index\n self.ind2tok[index] = token","def update(tokens):\n global TOKENS\n\n for token_id in tokens:\n\n if token_id not in TOKENS:\n TOKENS[token_id] = {}\n\n if isinstance(tokens, dict):\n token_info = tokens[token_id]\n if token_info is None:\n token_info = {}\n\n alias = token_info.get(\"alias\")\n if alias is not None:\n TOKENS[token_id][\"alias\"] = alias\n\n decimals = token_info.get(\"decimals\")\n if decimals is not None:\n TOKENS[token_id][\"decimals\"] = decimals","def intern_documents(documents: Dict[str, List[List[str]]], word_interner: Dict[str, int], unk_token: str):\n ret = dict()\n unk = word_interner[unk_token]\n for docid, sentences in documents.items():\n ret[docid] = [[word_interner.get(w, unk) for w in s] for s in sentences]\n return ret","def update_existing(doc_data_tples):\n def per_doc(doc, data_tples):\n def per_field(data_tple):\n field, datas = data_tple\n map(_do_append_field(doc, field), datas)\n map(per_field, data_tples)\n return doc\n\n __docs = ( (per_doc(doc, data_tples), data_tples) for doc,data_tples in doc_data_tples )\n return __docs","def updateDocumentAll(self, documents):\n docs = []\n for document in documents:\n if isinstance(document, couch.Document):\n document = document.getData()\n\n # these are required params\n if \"_id\" not in document or \"_rev\" not in document:\n raise Exception(\"Both _id & _rev fields are required!\")\n\n docs.append(document)\n\n return self.client.post(self.name +\"/_bulk_docs\", None,\n {\"docs\": docs}).getBodyData()","def update_from_document(self, document_path):\n with open(document_path, 'r') as document_file:\n for sentence in document_file:\n words = sentence.strip().split()\n for word in words:\n self._add_new_word(word)","def preprocess(self, documents):\n\n # A dict storing the frequency of each word\n word_freq = {}\n\n # Iterate for each document\n for doc in documents:\n # Split the document into a list of words and iterate on it\n for w in extract_words(doc):\n # Update word frequencies\n '''YOUR CODE HERE'''\n if w not in word_freq.keys():\n word_freq[w] = 1\n else:\n word_freq[w] += 1\n\n ''' END CODE FOR THIS LOOP '''\n\n\n # A set of words with frequency less than 'self.min_freq'\n remove_words = set()\n\n # Check frequency of each word and add to 'remove_words'\n # if it's frequency is below self.min_freq\n\n ''' YOUR CODE HERE '''\n for w in word_freq.keys():\n if word_freq[w] < self.min_freq:\n remove_words.add(w)\n\n # Delete the words in 'remove_words' from 'word_freq'\n for w in remove_words:\n del word_freq[w]\n\n # Fill 'self.word_to_idx' and 'self.idx_to_word' for\n # each word in 'word_freq' (dicts are explained above)\n\n i = 0\n for w in word_freq.keys():\n self.word_to_idx[w] = i\n self.idx_to_word[i] = w \n i += 1\n\n ''' END YOUR CODE HERE '''","def fit(self, documents):\n # Get a list of all the unique tokens that appear\n vocab = list({\n token for doc in documents\n for token in self.tokenizer(doc)\n if token not in self._word2index\n })\n\n # This is UNK, START, END, and PAD.\n nb_special_tokens = 4\n\n # First, we map token -> ID, leaving the first slots for special tokens\n self._word2index.update({\n word: idx\n for idx, word in enumerate(vocab, nb_special_tokens)\n })\n\n # Next, we invert this map, which we can do since it was built from\n # unique vocabulary elements and is by definition bijective.\n self._index2word.update({\n idx: word\n for word, idx in self._word2index.items()\n })\n\n return self","def multiple_document_processing(self) -> List:\n batch_list = []\n for doc, idx in self.__documents:\n entities_idx = {'idx': idx}\n entities_result = self.create_entity(document=doc)\n word_cleaned = self.clean_words(doc)\n entities_idx[self.key_spacy_text] = str(word_cleaned)\n entities_idx.update(entities_result)\n batch_list.append(entities_idx)\n return batch_list","def get_doc_dicts(self, doc_ids):\n pass","def updateMultipleDocuments(cred, payload):\n\n url = cred.base_url + \"documents:commit\"\n data = { 'writes': [] }\n\n for path, fieldData in payload.iteritems():\n pathData = createFirestoreDataObject(cred, path, fieldData)\n data['writes'].append(pathData)\n \n makeRequest(cred, url, 'POST', data)","def add_doc_in_posting_list(word_posting_list, docs):\n for doc_score in docs:\n if doc_score[\"doc\"] in word_posting_list.keys():\n word_posting_list[doc_score[\"doc\"]] = int(doc_score[\"score\"]) + int(word_posting_list[doc_score[\"doc\"]])\n else:\n word_posting_list[doc_score[\"doc\"]] = doc_score[\"score\"]","def load(self, documents, uniquify=False):\n assert documents, \"missing list of documents, text single doc per line\"\n assert isinstance(documents, list), \"documents must be list\"\n assert isinstance(documents[0], list), \"each document is also a list\"\n #--------------------------------------------------------------------------------------------\n\n def _get_new_counts(document):\n return Counter(document) if not uniquify else Counter(list(set(document)))\n\n for idx, document in enumerate(documents):\n new_counter = _get_new_counts(document)\n self.counter.update(new_counter)\n if idx % 1000 == 0:\n print(\"load: {}\\r\".format(idx), end='')\n return self","def parse_doc(self, doc_as_list):\n\n tweet_id = doc_as_list[0]\n tweet_date = doc_as_list[1]\n full_text = doc_as_list[2]\n url = doc_as_list[3]\n indice = doc_as_list[4]\n retweet_text = doc_as_list[5]\n retweet_url = doc_as_list[6]\n retweet_indice = doc_as_list[7]\n quote_text = doc_as_list[8]\n quote_url = doc_as_list[9]\n quoted_indice = doc_as_list[10]\n retweet_quoted_text = doc_as_list[11]\n retweet_quoted_url = doc_as_list[12]\n retweet_quoted_indice = doc_as_list[13]\n\n term_dict = {}\n\n tokenized_text = self.parse_sentence(full_text)\n tokenized_quote = self.parse_sentence(quote_text)\n # tokenized_url = self.handle_url(url)\n\n\n doc_length = len(tokenized_text) # after text operations - length of full_text\n\n new_tokenized_text = tokenized_text + tokenized_quote\n\n # spell checker\n # new_tokenized_text = self.spell.update(new_tokenized_text)\n\n for term in new_tokenized_text:\n if term is not \"\": # or (term.isalpha() and len(term) == 1)\n if term not in term_dict:\n term_dict[term] = 1\n else:\n term_dict[term] += 1\n\n document = Document(tweet_id, tweet_date, full_text, url, retweet_text, retweet_url, quote_text,\n quote_url, term_dict, doc_length)\n return document","def prepare_dictionary_from_docs(self):\n if os.path.exists(self.DICT_PATH):\n return True\n self.logger.info(\"START PREPARING DICT\")\n for fn in os.listdir(self.wiki_path):\n self.logger.info(\"dict update {0}\".format(fn))\n content = self.get_processed_content(fn)\n self.dictionary.add_documents([content])\n self.dictionary.filter_extremes(no_below=20, no_above=0.1, keep_n=100000)\n self.dictionary.compactify()\n self.dictionary.save(self.DICT_PATH)\n return True","def get_dict(cleaned_docs):\n data = []\n for doc in cleaned_docs:\n data += doc\n return list(set(data))","def transform(self, docs):\n return [doc for doc in docs]","def doc2bow(self, document, allow_update=False, return_missing=False):\n\n doc=[t.text for t in document.tokens]\n\n if isinstance(doc, string_types):\n raise TypeError(\"doc2bow expects an array of unicode tokens on input, not a single string\")\n\n # Construct (word, frequency) mapping.\n counter = defaultdict(int)\n for w in doc:\n counter[w if isinstance(w, str) else str(w, 'utf-8')] += 1\n\n token2id = self.token2id\n if allow_update or return_missing:\n missing = sorted(x for x in iteritems(counter) if x[0] not in token2id)\n if allow_update:\n for w, _ in missing:\n # new id = number of ids made so far;\n # NOTE this assumes there are no gaps in the id sequence!\n token2id[w] = len(token2id)\n result = {token2id[w]: freq for w, freq in iteritems(counter) if w in token2id}\n\n if allow_update:\n self.num_docs += 1\n self.num_pos += sum(itervalues(counter))\n self.num_nnz += len(result)\n # keep track of document and collection frequencies\n for tokenid, freq in iteritems(result):\n self.cfs[tokenid] = self.cfs.get(tokenid, 0) + freq\n self.dfs[tokenid] = self.dfs.get(tokenid, 0) + 1\n\n # return tokenids, in ascending id order\n result = sorted(iteritems(result))\n if return_missing:\n return result, dict(missing)\n else:\n return result","def _build_token_dict(self, corpus: List[List[str]]):\n self.token2idx = self.load_from_vocab_file(self.vocab_path)\n self.idx2token = dict([(value, key)\n for key, value in self.token2idx.items()])\n logging.debug(f\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\")\n self.dataset_info['token_count'] = len(self.token2idx)","def docs2ids(self):\n self.docs = [ [self.vocab[word] for word in doc] for doc in self.docs]","def update_all(cls, documents: List[dict]) -> (List[dict], List[dict]):\n if not documents:\n raise ValidationFailed([], message=\"No data provided.\")\n\n if not isinstance(documents, list):\n raise ValidationFailed(documents, message=\"Must be a list.\")\n\n new_documents = copy.deepcopy(documents)\n\n errors = cls.validate_and_deserialize_update(new_documents)\n if errors:\n raise ValidationFailed(documents, errors)\n\n try:\n if cls.logger.isEnabledFor(logging.DEBUG):\n cls.logger.debug(f\"Updating {new_documents}...\")\n previous_documents, updated_documents = cls._update_many(new_documents)\n if cls.logger.isEnabledFor(logging.DEBUG):\n cls.logger.debug(f\"Documents updated to {updated_documents}.\")\n return (\n [cls.serialize(document) for document in previous_documents],\n [cls.serialize(document) for document in updated_documents],\n )\n except pymongo.errors.DuplicateKeyError:\n raise ValidationFailed(\n [cls.serialize(document) for document in documents],\n message=\"One document already exists.\",\n )","def load_documents(data_dir: str, docids: Set[str] = None) -> Dict[str, List[List[str]]]:\n if os.path.exists(os.path.join(data_dir, 'docs.jsonl')):\n assert not os.path.exists(os.path.join(data_dir, 'docs'))\n return load_documents_from_file(data_dir, docids)\n\n docs_dir = os.path.join(data_dir, 'docs')\n res = dict()\n if docids is None:\n docids = sorted(os.listdir(docs_dir))\n else:\n docids = sorted(set(str(d) for d in docids))\n for d in docids:\n with open(os.path.join(docs_dir, d), 'r') as inf:\n lines = [l.strip() for l in inf.readlines()]\n lines = list(filter(lambda x: bool(len(x)), lines))\n tokenized = [list(filter(lambda x: bool(len(x)), line.strip().split(' '))) for line in lines]\n res[d] = tokenized\n return res","def load_documents_from_file(data_dir: str, docids: Set[str] = None) -> Dict[str, List[List[str]]]:\n docs_file = os.path.join(data_dir, 'docs.jsonl')\n documents = load_jsonl(docs_file)\n documents = {doc['docid']: doc['document'] for doc in documents}\n res = dict()\n if docids is None:\n docids = sorted(list(documents.keys()))\n else:\n docids = sorted(set(str(d) for d in docids))\n for d in docids:\n lines = documents[d].split('\\n')\n tokenized = [line.strip().split(' ') for line in lines]\n res[d] = tokenized\n return res","def initialize_terms_and_postings():\n global dictionary, postings\n for id in document_filenames:\n document = getDocumentContent(document_filenames[id])\n if(document_filenames[id].rfind(\".pdf\") == len(document_filenames[id]) - 4):\n terms = tokenize(document.encode('utf-8'))\n if(document_filenames[id].rfind(\".txt\") == len(document_filenames[id]) - 4):\n terms = tokenize(document)\n if(document_filenames[id].rfind(\".docx\") == len(document_filenames[id]) - 5):\n terms = tokenize(document)\n if(document_filenames[id].rfind(\".pptx\") == len(document_filenames[id]) - 5):\n terms = tokenize(document)\n unique_terms = set(terms)\n dictionary = dictionary.union(unique_terms)\n for term in unique_terms:\n postings[term][id] = terms.count(term) # the value is the\n # frequency of the\n # term in the\n # document","def _create_dictionary(self, document_set):\n words = self._normalize_words(document_set.words)\n unique_words = frozenset(words)\n return dict((word, idx) for idx, word in enumerate(unique_words))","def set_keyword_map(self):\n \n ret = defaultdict(list)\n for idx, doc in enumerate(self.docs):\n for token in doc:\n if token in self.dictionary.token2id:\n ret[token].append(idx)\n \n self.keyword_map = ret\n return ret","def clean_docs(self,docs):\n\n # Remove numbers, but not words that contain numbers.\n docs = [[token for token in doc if not token.isnumeric()] for doc in docs]\n\n # Remove words that are only one character.\n docs = [[token for token in doc if len(token) > 1 and token not in stop_words] for doc in docs]\n\n # lemmatizer = WordNetLemmatizer()\n # docs = [[lemmatizer.lemmatize(token) for token in doc] for doc in docs]\n\n # Add bigrams and trigrams to docs (only ones that appear 20 times or more).\n bigram = Phrases(docs, min_count=20)\n for idx in range(len(docs)):\n for token in bigram[docs[idx]]:\n if '_' in token:\n # Token is a bigram, add to document.\n docs[idx].append(token)\n\n # Create a dictionary representation of the documents.\n dictionary = Dictionary(docs)\n\n # Filter out words that occur less than 20 documents, or more than 50% of the documents.\n dictionary.filter_extremes(no_below=20, no_above=0.5)\n\n # Bag-of-words representation of the documents.\n corpus = [dictionary.doc2bow(doc) for doc in docs]\n\n return docs,dictionary,corpus","def add_new_doc(self, document, documents_list_length=10000):\n\n try:\n document_dictionary = document.term_doc_dictionary\n # self.countDoc += 1\n for term in document_dictionary.keys():\n if self.stemming == 'y':\n my_stemmer = Stemmer()\n term = my_stemmer.stem_term(term)\n # Update inverted index and posting\n if term not in self.inverted_idx.keys():\n self.inverted_idx[term] = [1, [\n (document_dictionary[term], document.tweet_id)]] # amount of doc, freq in the doc, doc id.\n\n else:\n self.inverted_idx[term][0] += 1 # amount of doc\n self.inverted_idx[term][1].append((document_dictionary[term],\n document.tweet_id)) # freq in the doc # doc id\n\n if term not in self.postingDict.keys():\n self.postingDict[term] = [(document.tweet_id, document_dictionary[term])]\n else:\n self.postingDict[term].append((document.tweet_id, document_dictionary[term]))\n # self.countTweet -= 1\n\n if document.tweet_id not in self.tweet_dict.keys():\n self.tweet_dict[document.tweet_id] = [[term, document_dictionary[term]], 1,\n 0] # [term,freq in tweet], amount of unique terms in tweet, amount of terms in tweet\n elif document_dictionary[term] > self.tweet_dict[document.tweet_id][0][\n 1]: # tweet exist, compering between freq in two terms\n if self.tweet_dict[document.tweet_id][0][\n 1] == 1: # before change term check if the last term is unique\n self.tweet_dict[document.tweet_id][\n 1] += 1 # last term is unique: add to the amount of uniqe terms in tweet\n self.tweet_dict[document.tweet_id][0] = [term,\n document_dictionary[term]] # change between the terms\n self.tweet_dict[document.tweet_id][2] += 1\n elif document_dictionary[term] == 1: # tweet exist, not most common, check if unique\n self.tweet_dict[document.tweet_id][1] += 1\n self.tweet_dict[document.tweet_id][2] += 1\n except:\n # print('problem in indexer : add_new_doc')\n # print(traceback.print_exc())\n pass","def add(self, document):\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\n if not token.isalpha():\n continue\n\n if token in self.stopwords:\n continue\n \n if self.stemmer:\n token = self.stemmer.stem(token)\n \n if self.__unique_id not in self.index[token]:\n self.index[token].append(self.__unique_id)\n \n self.documents[self.__unique_id] = document\n self.__unique_id += 1","def preprocess(self, documents):\n\n # Store the total number of documents\n num_docs = np.float(len(documents))\n\n # A dict storing the frequency of each word across all documents\n total_word_freq = {}\n\n # A dict storing the number of documents that word appears in\n doc_word_freq = {}\n\n # Iterate over all documents\n for doc in documents:\n # Split the string into a list of words\n words = extract_words(doc)\n\n # Update the 'total_word_freq' dict using all words in 'words'\n for w in words:\n ''' YOUR CODE HERE '''\n if w not in total_word_freq.keys():\n total_word_freq[w] = 1\n else:\n total_word_freq[w] += 1\n\n ''' END CODE FOR THIS LOOP '''\n\n # Update the 'doc_word_freq' dict. Remember to only add '1' corresponding to\n # each word in a document. In case a word appears twice in a document, then\n # it should be ignored. We use the set() data structure to achieve this.\n for w in set(words):\n ''' YOUR CODE HERE '''\n if w not in doc_word_freq:\n doc_word_freq[w] = 1\n else:\n doc_word_freq[w] += 1\n\n ''' END CODE FOR THIS LOOP '''\n\n # A set of words with total frequency less than 'self.min_freq'\n remove_words = set()\n\n ''' YOUR CODE HERE '''\n\n # Check frequency of each word and add to 'remove_words'\n for w in total_word_freq.keys():\n if total_word_freq[w] < self.min_freq:\n remove_words.add(w)\n\n # Delete the words in 'remove_words' from 'total_word_freq' and\n # 'doc_word_freq'.\n for w in remove_words:\n del total_word_freq[w]\n del doc_word_freq[w]\n\n # Create a numpy array to store frequencies from which\n # we can create the 'self.idf' preprocessed numpy array.\n word_freq_tensor = np.zeros(len(doc_word_freq))\n\n # For each word in 'doc_word_freq' dict, update\n # 'self.word_to_idx' and 'self.idx_to_word' and\n # 'word_freq_tensor'.\n i = 0\n for w in doc_word_freq.keys():\n self.word_to_idx[w] = i \n self.idx_to_word[i] = w\n word_freq_tensor[i] = doc_word_freq[w]\n i+=1\n \n #print(word_freq_tensor.shape)\n #print(word_freq_tensor)\n # Calculate 'self.idf' (see hint.pdf for formula)\n self.idf = -1*np.log(word_freq_tensor/(len(documents)))\n ''' END YOUR CODE HERE '''","def process_new_tokens(tokens,processed_tokens_set, model, dictionary):\n if hasattr(model, 'using_pretrained') and model.using_pretrained is not None:\n processed_tokens_set.update(tokens)\n update_embedding_layer(processed_tokens_set, model, dictionary)","def process_document(text):\n words = preprocess(text)\n postings = {}\n for word, ix in words:\n if word in postings:\n wordinfo = postings[word]\n else:\n wordinfo = {\"frequency\": 0, \"indexes\": []}\n postings[word] = wordinfo\n wordinfo[\"frequency\"] += 1\n wordinfo[\"indexes\"].append(ix)\n return postings","def pre_process(self, documents):\n\n return documents","def insert_many(self, documents: Iterable[dict]) -> None:\n for i, document in enumerate(documents):\n if isinstance(document, dict):\n self._store_document(document)\n else:\n raise TypeError(\n f\"The document at index {i} was not a dictionary. All documents must be dictionaries.\"\n )\n self._dump()","def _docMapping(self):\n doc2quests = defaultdict(list)\n for q, d in self.quest2doc.items():\n doc2quests[d].append(q)\n return doc2quests","def create_document_dictionary(documents):\n \n document_dictionary = dict()\n for document in documents:\n document_dictionary[document.cord_uid] = document\n return document_dictionary","def transform4Doc2Vec(docs):\n\n # transform documents to be used by doc2Vec\n documents = []\n analyzedDocument = namedtuple('AnalyzedDocument', 'words tags')\n for i, doc in enumerate(docs):\n # use first line if documents are not tokenized, otherwise next line\n # words = text.lower().split()\n tags = [i]\n documents.append(analyzedDocument(doc, tags))\n\n return documents","def _create_dictionary(self, document):\n words = self._normalize_words(document.words)\n unique_words = frozenset(words)\n return dict((word, idx) for idx, word in enumerate(unique_words))","def enrich(self, lazy_corpus_loader, fileids=None):\n tag_dict = self.tag_dict\n word_tag_dict = self.word_tag_dict\n for word_tag in lazy_corpus_loader.tagged_words(fileids=fileids):\n word = word_tag[0]\n tag = word_tag[1]\n if not tag_dict.get(tag, None):\n raise KeyError, \"Unknown pos-tag: %s\" % tag\n tag_dict = word_tag_dict.get(word, {})\n tag_dict[tag] = tag_dict.get(tag, 0) + 1\n word_tag_dict[word] = tag_dict\n self.word_tag_dict = word_tag_dict","def add(self, tokens):\n\n for token in tokens:\n self.vocab.add(token)\n\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\n if leader not in self.frequencies:\n self.frequencies[leader] = Frequency()\n\n self.frequencies[leader].add(token)","def set_doc_phrases(doc_phrases, docs, phrases):\n for doc in docs:\n if not doc in doc_phrases:\n doc_phrases[doc] = []\n doc_phrases[doc] = doc_phrases[doc] + phrases","def tokenize_document(doc_info: dict, tokenizer: BertTokenizer, max_doc_length: int = None) -> dict:\n sub_tokens: List[str] = [] # all sub tokens of a document\n sentence_map: List[int] = [] # collected tokenized tokens -> sentence id\n subtoken_map: List[int] = [] # collected tokenized tokens -> original token id\n\n word_idx = -1\n\n for sentence_id, sentence in enumerate(doc_info['sentences']):\n for token in sentence:\n word_idx += 1\n word_tokens = tokenizer.tokenize(token)\n sub_tokens.extend(word_tokens)\n sentence_map.extend([sentence_id] * len(word_tokens))\n subtoken_map.extend([word_idx] * len(word_tokens))\n if max_doc_length:\n num_to_pad = max_doc_length - len(sub_tokens)\n sub_tokens.extend([\"[PAD]\"] * num_to_pad)\n sentence_map.extend([sentence_map[-1]+1] * num_to_pad)\n subtoken_map.extend(list(range(word_idx+1, num_to_pad+1+word_idx)))\n # global MAX_LENGTH\n # if len(sub_tokens) > MAX_LENGTH:\n # print(len(sub_tokens))\n # MAX_LENGTH = len(sub_tokens)\n # print(MAX_LENGTH)\n # todo(yuxian): need pad speakers?\n speakers = {subtoken_map.index(word_index): tokenizer.tokenize(speaker)\n for word_index, speaker in doc_info['speakers']}\n clusters = [[(subtoken_map.index(start), len(subtoken_map) - 1 - subtoken_map[::-1].index(end))\n for start, end in cluster] for cluster in doc_info['clusters']]\n tokenized_document = {'sub_tokens': sub_tokens, 'sentence_map': sentence_map, 'subtoken_map': subtoken_map,\n 'speakers': speakers, 'clusters': clusters, 'doc_key': doc_info['doc_key']}\n return tokenized_document","def replace_words_fun(self):\n\n cleaned_doc = []\n for word in str(self.doc).split():\n if word.lower() in self.replacement_list.keys():\n cleaned_doc.append(self.replacement_list[word.lower()])\n else:\n cleaned_doc.append(word)\n self.doc = ' '.join(cleaned_doc)","def get_idf_dict(clean_corpus, tf_list, num_docs):\n \n idf_dict = {}\n for i in range(num_docs):\n for key in tf_list[i].keys():\n if key not in idf_dict.keys():\n idf_dict[key] = 0\n idf_dict[key] = idf_dict[key] + 1\n \n for key in idf_dict.keys():\n idf_dict[key] = math.log2(num_docs/idf_dict[key])\n # idf_dict's keys -> all unique tokens in the corpus \n return idf_dict","def initialize_document_frequencies():\n global document_frequency\n for term in dictionary:\n document_frequency[term] = len(postings[term])","def preprocess_corpus(corpus, stop_list, stop_words=True, stemm=True, bag_words=True):\n corpus_preprocessed = list()\n for element in corpus:\n new_element = dict()\n new_element['document'] = preprocess_document(element['text'], stop_list, stop_words, stemm, bag_words)\n new_element['id'] = element['id']\n corpus_preprocessed.append(new_element)\n\n return corpus_preprocessed","def create_tokens_li():\n cnt=0\n for file in docs:\n file_name = open(\"./corpus/\"+ str(file) + \".txt\")\n print(cnt)\n cnt+=1\n words = file_name.read()\n tokens_doc = nltk.word_tokenize(words)\n tokens_doc = [w.lower() for w in tokens_doc]\n #tokens_doc = [snowball_stemmer.stem(token) for token in tokens_doc]\n tokens_doc = [token for token in tokens_doc if token not in nltk.corpus.stopwords.words('english')]\n tokens_li.append(tokens_doc)\n\n\n #storing in json file\n with open('savers/tokens.json', 'w') as fp:\n json.dump(tokens_li, fp)","def documents(self, documents):\n\n self._documents = documents","def documents_to_dict(documents: List[Dict]) -> Dict[str, Dict]:\n res = {}\n for doc in documents:\n res[doc['id']] = doc\n return res","def map_docs(docs_file):\n word_map = defaultdict(int)\n doc_count = 0\n token_count = 0\n\n for _, doc_tokens in tokenize(docs_file):\n doc_count += 1 # count document\n token_count += len(doc_tokens) # count tokens\n for token in set(doc_tokens):\n word_map[token] += 1 # increase inverted index count\n\n docs_file.seek(0) # reset file pointer\n return doc_count, token_count, word_map","def updateScores(rankedLists):\n docToRank = {}\n for rankedList in rankedLists:\n\n f = open(rankedList, 'r')\n for line in f:\n documentID = line.split()[2]\n docno = documentID\n score = float(line.split()[4])\n position = int(line.split()[3])\n docToRank[docno] = (position,score)\n f.close()\n client = MongoClient('asr2.iem.technion.ac.il',27017)\n db = client.asr16\n documents = db.documents.find({})\n for document in documents:\n key = document[\"query_id\"]+\"-\"+document[\"username\"]\n document['position'] = docToRank[key][0]\n document['score'] = docToRank[key][1]\n document['posted_document'] = document['current_document']\n db.documents.save(document)","def merge_docs(self):","def run(self, mapping={}, *args, **kwargs):\n self.processed = 0\n for batch in self._process_by_batch(self.load(*args, **kwargs)):\n batch = list(map(lambda doc: self._apply_mapping(doc, mapping), batch))\n for doc in batch:\n self._ingest(iterable=doc, doctype=doc[\"doctype\"])\n self.processed += 1\n logger.info(\"Added {} documents to the database.\".format(self.processed))","def make_vocab_from_docs(docs):\n vocab_words=set()\n for doc in docs:\n doc=doc.lower()\n doc=re.sub(r'-',' ',doc)\n doc=re.sub(r' +',' ',doc) # turn multiple spaces into a single space\n doc=re.sub(r'[^a-z ]','',doc) # remove anything that is not a-z or space\n words=set(doc.split())\n vocab_words=vocab_words.union(words)\n vocab=dict(zip(vocab_words,range(len(vocab_words))))\n return vocab","def _prepare_analysis_input(self, documents):\n subdoc_to_doc_map = {}\n wordtype_to_number = {}\n number_to_wordtype = []\n wordtypes = {}\n \n # prevent duplicating work\n if os.path.exists(self.wordtype_file):\n return\n \n try:\n # First find singletons\n if self.remove_singletons:\n word_type_count_threshold = max(1, int(math.log(documents.count(), 10)) - 2)\n temp_word_type_counts = {}\n for doc_index, doc in enumerate(documents):\n tokens = self.tokenize(doc.get_content())\n for token, token_start in tokens:\n temp_word_type_counts[token] = temp_word_type_counts.setdefault(token, 0) + 1\n for word_type, count in temp_word_type_counts.iteritems(): # add singletons to stopword list\n if count <= word_type_count_threshold:\n self._excluded_words[word_type] = True\n with io.open(self.excluded_words_file, 'w', encoding='utf-8') as ex_f:\n ex_f.write(unicode(json.dumps(self._excluded_words)))\n \n haltwords = dict(self.stopwords)\n haltwords.update(self._excluded_words)\n # Second find bigrams, iterate through documents and train.\n if self.find_bigrams:\n from import_tool.analysis.bigram_finder import BigramFinder\n bigram_finder = BigramFinder(stopwords=haltwords)\n for doc_index, doc in enumerate(documents):\n bigram_finder.train(doc_index, self.tokenize(doc.get_content()))\n bigram_finder.print()\n \n # Third, we're going to stem words\n if self.stem_words:\n from import_tool.analysis.stemmer import Stemmer\n stemmer = Stemmer(self._working_dir, self.base_dir)\n \n # for each document tokenize and map tokens to numbers to avoid regex problems before passing data to Mallet\n with io.open(self.mallet_input_file, 'w', encoding='utf-8') as w:\n with io.open(self.start_index_file, 'w', encoding='utf-8') as w2:\n count = 0\n subcount = 0\n for doc_index, doc in enumerate(documents):\n doc_content = unicode(doc.get_content())\n count += 1\n subdocuments = self.create_subdocuments(doc_index, doc_content)\n token_start_index_offset = 0 # needed to make sure the start index remains correct once the document is re-merged\n for subdoc_name, subdoc_content in subdocuments:\n if subcount > 0:\n w2.write(u'\\n')\n subcount += 1\n subdoc_to_doc_map[subdoc_name] = doc_index\n tokens = self.tokenize(subdoc_content)\n \n if self.find_bigrams:\n tokens = bigram_finder.combine(tokens, subdoc_content)\n \n token_numbers = []\n token_start_indices = []\n only_tokens = []\n tokens_temp = []\n for tok, tok_start in tokens:\n only_tokens.append(tok)\n tokens_temp.append([tok, tok_start + token_start_index_offset])\n tokens = tokens_temp\n tokens_temp = None\n if self.stem_words:\n stemmed_tokens = stemmer.stem(only_tokens)\n else:\n stemmed_tokens = only_tokens\n for tup, tok_stem in zip(tokens, stemmed_tokens):\n tok, tok_start = tup\n wordtypes[tok] = True\n wordtypes[tok_stem] = True\n try:\n tok_num = wordtype_to_number[tok_stem]\n except:\n tok_num = len(wordtype_to_number)\n number_to_wordtype.append(tok_stem)\n wordtype_to_number[tok_stem] = tok_num\n token_numbers.append(unicode(tok_num))\n token_start_indices.append([tok, tok_start])\n text = u' '.join(token_numbers)\n w.write(u'{0} all {1}\\n'.format(subdoc_name, text))\n w2.write(unicode(json.dumps(token_start_indices)))\n token_start_index_offset += len(subdoc_content)\n for tok, tok_start in tokens:\n try:\n assert doc_content[tok_start:tok_start+len(tok)].lower() == tok.lower()\n except:\n print(tok_start)\n print(len(tok))\n print('\"'+doc_content[tok_start:tok_start+len(tok)].lower()+'\"')\n print('\"'+tok.lower()+'\"')\n raise\n if not count:\n raise Exception('No files processed.')\n # record which subdocuments belong to which documents\n with io.open(self.subdoc_to_doc_map_file, 'w', encoding='utf-8') as w:\n w.write(unicode(json.dumps(subdoc_to_doc_map)))\n with io.open(self.wordtype_to_number_file, 'w', encoding='utf-8') as w:\n w.write(unicode(json.dumps(wordtype_to_number)))\n with io.open(self.number_to_wordtype_file, 'w', encoding='utf-8') as w:\n w.write(unicode(json.dumps(number_to_wordtype)))\n with io.open(self.wordtype_file, 'w', encoding='utf-8') as w:\n w.write(unicode(json.dumps(wordtypes)))\n except: # cleanup\n self._cleanup(self.mallet_input_file)\n self._cleanup(self.subdoc_to_doc_map_file)\n self._cleanup(self.wordtype_to_number_file)\n self._cleanup(self.number_to_wordtype_file)\n self._cleanup(self.wordtype_file)\n self._cleanup(self.excluded_words_file)\n raise","def current_word_PL(current_word, file_reader_last_read_list, doc_dict, nb_doc):\n word_posting_list = {} # { key = doc , value = score }\n for idx, file_reader_last_read in enumerate(file_reader_last_read_list):\n if file_reader_last_read[\"last_read\"][\"word\"] == current_word:\n docs = file_reader_last_read[\"last_read\"][\"doc_score_list\"]\n add_doc_in_posting_list(word_posting_list=word_posting_list, docs=docs)\n file_reader_last_read_list[idx]=read_line_and_update(file_reader_and_last_read=file_reader_last_read)\n for key, value in word_posting_list.items():\n tf = float(value) / doc_dict[int(key)]\n idf = math.log((float(nb_doc)/len(word_posting_list)),2)\n score = tf*idf\n word_posting_list[key]=score \n word_posting_list = sort_and_cast_doc_in_posting_list(word_posting_list=word_posting_list)\n return word_posting_list","async def put_documents(self, collection, documents):\n await self.ensure_collection(collection)\n try:\n if SOLR_COMMIT_WITHIN:\n params = {'commitWithin': SOLR_COMMIT_WITHIN}\n else:\n params = {'commit': 'true'}\n await self.post(\n '/v2/collections/{}/update'.format(collection),\n params=params, json_data=documents\n )\n logger.info('Successfully indexed {} documents to collection {}'\n .format(len(documents), collection))\n except SolrError:\n logger.warning('Failed to put {} documents to collection {}'\n .format(len(documents), collection))\n raise","def from_documents(cls, documents):\n # return cls.from_words(_itertools.chain(*documents))\n return cls.from_words(\n cls._build_new_documents(documents, cls.default_ws, pad_right=True)\n )","def add_new_doc(self, document, end_of_corpus):\n max_tf = 0\n unique_terms_counter = 0\n document_dictionary = document.term_doc_dictionary\n # Go over each term in the doc\n for term in document_dictionary:\n try:\n # Update inverted index and posting\n if term not in self.inverted_idx:\n self.inverted_idx[term] = 1\n unique_terms_counter += 1\n else:\n self.inverted_idx[term] += 1\n if term not in self.posting_dict:\n self.posting_dict[term] = []\n\n self.posting_dict[term].append(\n (document.tweet_id, document_dictionary[term])) # key: str , value: array of tuples\n\n max_tf = max(document_dictionary[term], max_tf)\n\n except:\n\n print('problem with the following key {}'.format(term[0]))\n\n document.max_tf = max_tf\n document.unique_terms = unique_terms_counter\n self.docs_count += 1\n\n modulo = int(document.tweet_id) % 10\n self.documents[modulo][document.tweet_id] = [document.term_doc_dictionary, document.max_tf]\n\n if self.docs_count == self.DOCS_SIZE or end_of_corpus: # if we reach chunk size or end of corpus\n self.add_to_file(end_of_corpus)\n self.docs_count = 0\n self.posting_dict = {}\n\n for i in self.documents: # 0 - 9\n if self.documents[i].__len__() > 15000:\n doc = utils.load_obj(self.out + \"document\" + str(i))\n doc.update(self.documents[i])\n utils.save_obj(doc, self.out + \"document\" + str(i))\n self.documents[i] = {}","def upload(self, documents: List[Document], vectorise_func) -> None:\n\n # Add doc_store to documents\n for d in documents:\n d.doc_store = self\n # Check ID uniqueness\n check_duplicate_documents(documents)\n # Check type consistency\n check_document_types(documents)\n # Batching\n batches = batch_items(documents)\n\n # Update document class conveniently\n if issubclass(type(documents[0]), ChunkedDocument):\n self._doc_class = ChunkedDocument\n\n for batch in batches:\n vectorise_func(batch, self)\n self.documents += batch","def add_doc(self, document):\n # Split document up into list of strings\n #words = self.tokenize(document)\n words = document\n # Count word frequencies in this document\n word_counts = {}\n for word in words:\n word_counts[word] = word_counts.get(word, 0) + 1\n # Add word counts as new row to sparse matrix\n self.sparse.append(word_counts)\n # Add to total document count for each word\n for word in word_counts:\n self.doc_count[word] = self.doc_count.get(word, 0) + 1","def _merge_conllu_subtokens(self, lines: List[str], doc: Doc)-> Doc:\n # identify and process all subtoken spans to prepare attrs for merging\n subtok_spans = []\n for line in lines:\n parts = line.split(\"\\t\")\n id_, word, lemma, pos, tag, morph, head, dep, _1, misc = parts\n if \"-\" in id_:\n subtok_start, subtok_end = id_.split(\"-\")\n subtok_span = doc[int(subtok_start) - 1 : int(subtok_end)]\n subtok_spans.append(subtok_span)\n # create merged tag, morph, and lemma values\n tags = []\n morphs = {}\n lemmas = []\n for token in subtok_span:\n tags.append(token.tag_)\n lemmas.append(token.lemma_)\n if token._.merged_morph:\n for feature in token._.merged_morph.split(\"|\"):\n field, values = feature.split(\"=\", 1)\n if field not in morphs:\n morphs[field] = set()\n for value in values.split(\",\"):\n morphs[field].add(value)\n # create merged features for each morph field\n for field, values in morphs.items():\n morphs[field] = field + \"=\" + \",\".join(sorted(values))\n # set the same attrs on all subtok tokens so that whatever head the\n # retokenizer chooses, the final attrs are available on that token\n for token in subtok_span:\n token._.merged_orth = token.orth_\n token._.merged_lemma = \" \".join(lemmas)\n token.tag_ = \"_\".join(tags)\n token._.merged_morph = \"|\".join(sorted(morphs.values()))\n token._.merged_spaceafter = (\n True if subtok_span[-1].whitespace_ else False\n )\n\n with doc.retokenize() as retokenizer:\n for span in subtok_spans:\n retokenizer.merge(span)\n\n return doc","def _apply_mapping(self, document, mapping):\n if not mapping:\n return document\n new_document = {v: document[k] for k, v in mapping.items() if k in document}\n # Keep track of missing keys\n self.missing_keys.update([k for k in mapping if k not in document])\n\n # Document errors for missing documents\n if not new_document:\n self.failed += 1\n self.failed_ids.append(\n document.get(\"id\", document.get(\"ID\", document.get(\"_id\", None)))\n )\n return new_document","def count_doc_frequencies(self, docs):\n frequencyIndex = {}\n doc_id = 0\n for doc in docs:\n for term in doc:\n if term not in frequencyIndex:\n frequencyIndex[term] = [doc_id]\n else:\n for id in frequencyIndex[term]:\n if doc_id == id:\n break\n else:\n frequencyIndex[term].append(doc_id)\n doc_id+=1\n\n for term in frequencyIndex:\n occurences = len(frequencyIndex[term])\n frequencyIndex[term] = occurences\n\n return frequencyIndex","def set_documents(cls, input_list_text: List[str]) -> None:\n cls.documents = input_list_text","def featurize(movies):\n ###TODO \n movies['features'] = \"\" \n get_h = set() \n vocab_dict = {}\n df_dict_return = {}\n tup_list = []\n index_dict = {}\n index_dict_1 = {}\n movie_len = len(movies) \n #print(\"MovieLength::\",movie_len)\n #print(\"MOVIES:::\",movies)\n \n get_h = cal_unique_features(movies) # num_features\n\n vocab_dict = cal_unique_vocab(get_h) # vocab complete\n\n len_vocab = len(get_h)\n \n df_dict_return = cal_unique_docs(get_h,movies) # df(i)\n\n for token in get_h :\n #tup_list.clear()\n #print(\"token_GOTTTTT:::\",token)\n for index,row in movies.iterrows(): \n #print(\"row_got::\",row)\n gen_list = row['tokens']\n #print(\"gen_list::\",gen_list)\n #mov_id = row['movieId'] \n #print(\"mov_id::\",mov_id)\n token_count_1 = Counter(gen_list).most_common()[:1]\n tok = token_count_1[0]\n index_dict_1[index] = tok[1]\n token_count = gen_list.count(token)\n #print(\"token_count::\",token_count)\n tup = (index,token_count)\n #print(\"tuple::\",tup)\n tup_list.append(tup)\n #print(\"LIST_PRINT:::::::::::::\",tup_list)\n index_dict[token] = tup_list\n tup_list = []\n \n \n #print(\"INDEX_DICT:::\",index_dict) # tf(i,d)\n #print(\"INDEX_DICT_1:::\",index_dict_1) # max_k dict per docx\n \n \n for ind, row in movies.iterrows():\n data_list = []\n rows_list = []\n columns_list = []\n gen_list = row['tokens']\n #print(\"TOKENS GOTTT::\",gen_list) \n for gen in gen_list:\n tf = get_tf_value(index_dict,gen,ind)\n #print(\"TF GOTTT::\",tf) \n tf_weight = float( tf / index_dict_1[ind])\n #print(\"tf_weight::\",tf_weight)\n df_weight = float( math.log10( movie_len / df_dict_return[gen] ) )\n #print(\"df_weight::\",df_weight)\n final_tfidf = tf_weight * df_weight\n #print(\"final_tfidf::\",final_tfidf)\n data_list.append(final_tfidf)\n columns_list.append(vocab_dict[gen])\n rows_list.append(0) \n csr = csr_matrix((data_list, (rows_list,columns_list)), shape=(1,len_vocab))\n #print(\"TYPE of CSR GOTT::\",type(csr))\n #print(\"CSR GOTT:::\",csr) \n movies.set_value(ind, 'features', csr)\n \n #print(\"UPDATE movies::\",movies) \n\n return(movies,vocab_dict)\n \n\n pass","def index_terms(self):\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\n self.doc_store.dict.iteritems()]","def updateWordCounts():\n emaildata = loadEmailData()\n englishwords = importDictionary()\n countAllWords(emaildata, englishwords)","def set_document_numbers(notices):\n\n if len(notices) > 1:\n for notice in notices:\n notice['document_number'] = split_doc_num(\n notice['document_number'], notice['effective_on'])\n return notices","def set_document_numbers(notices):\n\n if len(notices) > 1:\n for notice in notices:\n notice['document_number'] = split_doc_num(\n notice['document_number'], notice['effective_on'])\n return notices","def update(self, docs: DocumentArray, *args, **kwargs):\n cursor = self.connection.cursor()\n psycopg2.extras.execute_batch(\n cursor,\n f'UPDATE {self.table} SET DOC = %s WHERE ID = %s',\n [\n (\n doc.SerializeToString(),\n doc.id,\n )\n for doc in docs\n ],\n )\n self.connection.commit()","def updateWordList(emailids):\n with open('res/dictionary.txt', 'r') as f:\n lines = f.readlines()\n words = set([line.strip() for line in lines])\n\n with open('res/dictionary.txt', 'a') as f:\n for emailid in emailids: \n email = e.Email(emailid)\n subject = set(email.parsedsubject)\n body = set(email.body)\n try:\n emailcontent = body.union(subject)\n for word in emailcontent:\n if not word in words:\n words.add(word)\n f.write(word + '\\n')\n except AttributeError:\n print(body)","def add_documents(self, docs):\n for doc in docs:\n assert isinstance(doc, pylastica.document.Document), \"All items in list docs must be of type Document: %r\" % doc\n doc.doc_type = self.name\n return self.index.add_documents(docs)","def update_documents(self, engine_name, documents):\n endpoint = \"engines/{}/documents\".format(engine_name)\n data = json.dumps(documents)\n\n return self.swiftype_session.request('patch', endpoint, data=data)","def create_freq_dict(corpus, doc_info):\n for idx, content in enumerate(corpus):\n word_freq_table = {}\n splitted_sentence = content.split()\n for word in splitted_sentence:\n word = word.lower()\n if word not in word_freq_table:\n word_freq_table[word] = 1\n else:\n word_freq_table[word] += 1\n doc_info[idx]['freq_dict'] = word_freq_table","def index_feats_dict(self):\n doc_features_dict = {}\n\n for index, doc in zip(self.index, self.series):\n # Sets for a doc and feature words\n doc_set = set(doc.split())\n feat_set = set(self.features)\n\n # Shared words between the two sets\n interset_words = doc_set.intersection(feat_set)\n\n # Append to doc_features_dict\n doc_features_dict[index] = list(interset_words)\n\n return doc_features_dict","def pos():\n pos_list = []\n for token in doc:\n pos_list.append(token.pos_)\n setList = list(set(pos_list))\n my_dict = {i: pos_list.count(i) for i in setList}\n print(my_dict)","def finish_documents():\n\n doc_ids = json.loads(request.form['doc_ids'])\n\n for docid in doc_ids:\n\n document = Document.query.filter_by(id=docid).first_or_404()\n\n document.status = \"OK\"\n\n db.session.add(document)\n\n db.session.commit()","def test_update_list(self):\n u = stellr.UpdateCommand(TEST_HTTP)\n docs = [{'a': 1}, {'b': 2}]\n u.add_documents(docs)\n self.assertEqual(2, len(u._commands))\n self.assertEqual(u.body,\n ('{\"add\": {\"doc\": {\"a\": 1}}'\n ',\"add\": {\"doc\": {\"b\": 2}}}'))","def add_documents(self, documents):\n\t\t\n\t\t# flag for StopIteration exceptions\n\t\tmore_documents = True\n\t\t# loop while there are still documents in the iterator\n\t\twhile more_documents:\n\t\t\t# increment batch number\n\t\t\tbatch = len(self.batch_stats) + 1\n\t\t\t# count sentences\n\t\t\tsentences_count = 0\n\t\t\t# create temporary batch data file in the version directory\n\t\t\tbatch_file = os.path.join(self.file_base.get_version_path(self.version), \"data.jl.gz.temp\")\n\t\t\t# try to read the next batch of files, catch exception and stop if there are no more\n\t\t\ttry:\n\t\t\t\t# get next document before opening the file just to make sure it's there\n\t\t\t\tdocument = documents.next()\n\t\t\t\t# open the data file\n\t\t\t\twith gzip.open(batch_file, \"wb\") as outfile:\n\t\t\t\t\t# loop through DOCUMENT_BATCH_SIZE documents\n\t\t\t\t\tfor i in range(DocumentDatabase.DOCUMENT_BATCH_SIZE):\n\t\t\t\t\t\t# count sentences in document\n\t\t\t\t\t\tfor paragraph in document[\"paragraphs\"]:\n\t\t\t\t\t\t\tsentences_count += len(paragraph[\"sentences\"])\n\t\t\t\t\t\t# write JSON to file one line at a time\n\t\t\t\t\t\toutfile.write(\"%s\\n\" % json.dumps(document))\n\t\t\t\t\t\t# if we are not done with this batch, retrieve the next document\n\t\t\t\t\t\tif i < DocumentDatabase.DOCUMENT_BATCH_SIZE - 1:\n\t\t\t\t\t\t\tdocument = documents.next()\n\t\t\texcept StopIteration:\n\t\t\t\t# the end of the documents stream, set the flag to False\n\t\t\t\tmore_documents = False\n\t\t\t# make sure the batch isn't empty\n\t\t\tif sentences_count > 0:\n\t\t\t\t# create the new batch in the file system\n\t\t\t\tself.version_batches.create_latest_version()\n\t\t\t\t# add the stats to the statistics hash\n\t\t\t\tself.batch_stats[batch] = BatchStats(sentences_count)\n\t\t\t\t# write the batch statistics to file\n\t\t\t\twith codecs.open(self._get_batch_stat_file(batch), \"wb\", \"utf-8\") as outfile:\n\t\t\t\t\t# write the JSON representation for the stats\n\t\t\t\t\toutfile.write(json.dumps(self.batch_stats[batch].to_json()))\n\t\t\t\t# move the temp data file to the correct location inside the version folder\n\t\t\t\tos.rename(batch_file, self._get_batch_file(batch))","def get_preprocessed_docs(formatted_docs):\r\n preprocessed_docs = {}\r\n for idx in formatted_docs.keys():\r\n preprocessed_docs[idx] = preprocess(formatted_docs[idx])\r\n return preprocessed_docs","def load_flattened_documents(data_dir: str, docids: Set[str]) -> Dict[str, List[str]]:\n unflattened_docs = load_documents(data_dir, docids)\n flattened_docs = dict()\n for doc, unflattened in unflattened_docs.items():\n flattened_docs[doc] = list(chain.from_iterable(unflattened))\n return flattened_docs","def build(self,documents):\n\t\tself.vectorKeywordIndex = self.getVectorKeywordIndex(documents)\n\n\t\tself.documentVectors = [self.createVector(document) for document in documents]","def _build_token_dict(self, corpus: List[List[str]], min_count: int = 3):\n token2idx = {\n self.token_pad: 0,\n self.token_unk: 1,\n self.token_bos: 2,\n self.token_eos: 3\n }\n\n token2count = {}\n for sentence in corpus:\n for token in sentence:\n count = token2count.get(token, 0)\n token2count[token] = count + 1\n\n # 按照词频降序排序\n sorted_token2count = sorted(token2count.items(),\n key=operator.itemgetter(1),\n reverse=True)\n token2count = collections.OrderedDict(sorted_token2count)\n\n for token, token_count in token2count.items():\n if token not in token2idx and token_count >= min_count:\n token2idx[token] = len(token2idx)\n\n self.token2idx = token2idx\n self.idx2token = dict([(value, key)\n for key, value in self.token2idx.items()])\n logging.debug(f\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\")\n self.dataset_info['token_count'] = len(self.token2idx)","def update_words(data, book_num):\n\tglobal word_count\n\t#find count of each word in the book and update the dictionary\n\tfor words in data:\n\t\tword_count[words][book_num] = (word_count.get(words,0)[book_num] + 1)\n\t#print(word_count)","def generate_dict(self):\n dict = defaultdict(list)\n for i in range(self.no_of_docs-1):\n doc_txt = self.doc_to_df(i)\n #assign key to index in dictionary and its locations as tuples(docid,line,wordpos) as the values\n for j in range(len(doc_txt)):\n for k in range(doc_txt.shape[1]):\n key = doc_txt[k][j]\n dict[key].append((i,j,k))","def set(self, doc, fields_values):\n fields_values = Object.from_bson(fields_values)\n for k,v in fields_values.items():\n self._set(doc, k.split('.'), v)\n impl = self._impl(doc)\n return impl.update({'_id':doc._id}, {'$set':fields_values})","def parse_doc(self, doc_as_list):\n tweet_id = doc_as_list[0]\n tweet_date = doc_as_list[1]\n full_text = doc_as_list[2]\n url = doc_as_list[3]\n retweet_text = doc_as_list[4]\n retweet_url = doc_as_list[5]\n quote_text = doc_as_list[6]\n quote_url = doc_as_list[7]\n term_dict = {}\n tokenized_text = self.parse_sentence(full_text)\n doc_length = len(tokenized_text) # after text operations.\n\n for i, term in enumerate(tokenized_text):\n if term not in term_dict.keys():\n term_dict[term] = [1, [i]]\n else:\n term_dict[term][0] += 1\n term_dict[term][1].append(i)\n\n document = Document(tweet_id, tweet_date, full_text, url, retweet_text, retweet_url, quote_text,\n quote_url, term_dict, doc_length)\n return document","def extract(self, documents):\n\n # Feature vector to return\n features = np.zeros((len(documents), len(self.idx_to_word)))\n\n # Raise an exception if 'extract' is called before 'preprocess'\n if len(self.word_to_idx) == 0 or len(self.idx_to_word) == 0:\n raise Exception(\"Dictionary not initialised.\")\n\n # Iterate over all documents\n for idx, doc in enumerate(documents):\n # Split the doc into a list of words\n words = extract_words(doc)\n\n # For each word\n for w in words:\n # Calculate it's frequency, however, keep in mind\n # that this word may not have been in the training\n # corpus. In that case, ignore the word.\n ''' YOUR CODE HERE '''\n try:\n features[idx][self.word_to_idx[w]] = words.count(w)\n except KeyError:\n pass\n\n ''' END CODE FOR THIS LOOP '''\n\n # Divide the vector by the total number of words in the document to\n # normalize the frequencies.\n ''' YOUR CODE HERE '''\n features[idx] = features[idx]/len(words)\n ''' END CODE FOR THIS LOOP '''\n\n return features","def _vector_mapping(self) -> dict:\n words = set()\n for file in os.listdir(self.processed_path):\n doc_path = f\"{self.processed_path}/{file}\"\n with open(doc_path, 'r') as f:\n text_words = f.readline().split()\n words = words.union(set(text_words))\n words = list(words)\n words.sort()\n\n return dict(zip(words, range(len(words))))","def add(self, token_docid):\n token = token_docid[0]\n doc_id = token_docid[1]\n # collapse identical tokens together\n if token in self.posting:\n self.posting[token].append(doc_id)\n else:\n self.posting[token] = [doc_id]","def __call__(self, doc: Doc) -> Doc:\n for val in self._get_vals(doc):\n key = self._get_key(val)\n try:\n self._table.get(key).append(val)\n except AttributeError:\n self._table.set(key, [val])\n self._size += 1\n return super().__call__(doc)","def __parse_corpus(self, corpus):\n corpus = self.__handle_corpus_unkwon_words(corpus)\n start_token = ' '.join([NGramModel.START_SENTENCE_TOKEN]*(self.__n-1))\n word_list = corpus.replace(NGramModel.START_SENTENCE_TOKEN, start_token).split()\n \n for n in range(1, self.__n+1): \n self.__ngram_counts[n] = {}\n for ngram, count in Counter(self.__generate_n_grams(word_list, n)).items():\n self.__ngram_counts[n][' '.join(ngram)] = count","def documents(self, **kw):\r\n \r\n doc_reader = self.doc_reader\r\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))","def merge_all_claims_norm_dicts_for_docs(): \n# docs_norm_scores_dicts_path = base_path+\"\\\\docs_norm_scores_dicts\"\n docs_norm_scores_dicts_path = linux_base_path+\"/docs_norm_scores_dicts\"\n# all_claims_norms_scores_merged_dict = base_path +\"\\\\all_claims_norms_scores_merged_dict\"\n all_claims_norms_scores_merged_dict = linux_base_path +\"/all_claims_norms_scores_merged_dict\"\n for alpha in range(0,11,1):\n for beta in range(0,10,1):\n docs_scores_all_claims = {}\n for filename in os.listdir(docs_norm_scores_dicts_path):\n (alpha_f,beta_f)=turn_to_float([alpha,beta])\n if \"_alpha_\"+str(alpha_f)+\"_\" in filename and \"_beta_\"+str(beta_f)+\"_\" in filename:\n curr_dict = read_pickle(docs_norm_scores_dicts_path+\"/\"+filename)\n docs_scores_all_claims = dict(docs_scores_all_claims.items() + curr_dict.items()) #merge dicts\n save_pickle(all_claims_norms_scores_merged_dict+\"/docs_norm_scores_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f),docs_scores_all_claims)","def tokenize_replace_pos(doc_list, language_code, replace_pos,\n core_num=multiprocessing.cpu_count()):\n param = [[d, language_code, replace_pos] for d in doc_list]\n pool = multiprocessing.Pool(core_num)\n return pool.map(_tokenize_replace_pos4map, param)","def refine_tokens( self, tokens ):\n k = 1.75\n b = 0.75\n stop_words_file = \"stop_words.txt\"\n all_stopwords = list()\n refined_tokens_sources = dict()\n \n # collect all the stopwords\n with open( stop_words_file ) as file:\n lines = file.read()\n all_stopwords = lines.split( \"\\n\" )\n \n for source in tokens:\n refined_tokens = dict()\n files = dict()\n inverted_frequency = dict()\n file_id = -1\n total_file_length = 0\n for item in tokens[ source ]:\n file_id += 1\n file_tokens = tokens[ source ][ item ].split(\" \")\n if source in \"name_desc_edam_help\":\n file_tokens = utils._clean_tokens( file_tokens, all_stopwords )\n total_file_length += len( file_tokens )\n term_frequency = dict()\n for token in file_tokens:\n if token is not '':\n file_ids = list()\n if token not in inverted_frequency:\n file_ids.append( file_id )\n else:\n file_ids = inverted_frequency[ token ]\n if file_id not in file_ids:\n file_ids.append( file_id )\n inverted_frequency[ token ] = file_ids\n # for term frequency\n if token not in term_frequency:\n term_frequency[ token ] = 1\n else:\n term_frequency[ token ] += 1\n files[ item ] = term_frequency\n N = len( files )\n average_file_length = float( total_file_length ) / N\n # find BM25 score for each token of each tool. It helps to determine\n # how important each word is with respect to the tool and other tools\n for item in files:\n file_item = files[ item ]\n file_length = len( file_item )\n for token in file_item:\n tf = file_item[ token ]\n # normalize the term freq of token for each document\n tf = float( tf ) / file_length\n idf = np.log2( N / len( inverted_frequency[ token ] ) )\n alpha = ( 1 - b ) + ( float( b * file_length ) / average_file_length )\n tf_star = tf * float( ( k + 1 ) ) / ( k * alpha + tf )\n tf_idf = tf_star * idf\n file_item[ token ] = tf_idf\n # filter tokens based on the BM25 scores and stop words. Not all tokens are important\n for item in files:\n file_tokens = files[ item ]\n tokens_scores = [ ( token, score ) for ( token, score ) in file_tokens.items() ]\n sorted_tokens = sorted( tokens_scores, key=operator.itemgetter( 1 ), reverse=True )\n refined_tokens[ item ] = sorted_tokens\n tokens_file_name = 'tokens_' + source + '.txt'\n token_file_path = os.path.join( os.path.dirname( self.tools_data_path ) + '/' + tokens_file_name )\n with open( token_file_path, 'w' ) as file:\n file.write( json.dumps( refined_tokens ) )\n file.close()\n refined_tokens_sources[ source ] = refined_tokens\n return refined_tokens_sources","def build_ngram_index(tokenized_documents, ngrams):\n dictionary = {}\n\n doc_ngrams = {}\n for doc in tokenized_documents:\n ngrams_freq = {}\n\n measures = nltk.collocations.BigramAssocMeasures()\n finder = BigramCollocationFinder.from_words(tokenized_documents[doc])\n freqs = finder.ngram_fd\n for ngram in freqs:\n ngrams_freq[ngram] = freqs[ngram]\n \n measures = nltk.collocations.TrigramAssocMeasures()\n finder = TrigramCollocationFinder.from_words(tokenized_documents[doc])\n freqs = finder.ngram_fd\n for ngram in freqs:\n ngrams_freq[ngram] = freqs[ngram]\n\n doc_ngrams[doc] = ngrams_freq\n\n for ngram in ngrams:\n dictionary[ngram] = [0]\n for doc in doc_ngrams:\n if ngram in doc_ngrams[doc]:\n dictionary[ngram][0] += doc_ngrams[doc][ngram]\n dictionary[ngram].append((doc, doc_ngrams[doc][ngram]))\n \n return dictionary"],"string":"[\n \"def add_documents(self, docs):\\n for sent in docs:\\n sent = map(self.process_token, sent)\\n self._token_count.update(sent)\",\n \"def add_document_lists(self, docs):\\n for sent in docs:\\n sent = map(self.process_token, sent)\\n self._token_count.update(sent)\",\n \"def add_to_dict(self, tokens):\\n# TODO: ?add normalization of a token?\\n for token in tokens:\\n if self.embedding_words and (token not in self.embedding_words):\\n continue\\n self.freq[token] += 1\\n if token not in self.tok2ind:\\n index = len(self.tok2ind)\\n self.tok2ind[token] = index\\n self.ind2tok[index] = token\",\n \"def update(tokens):\\n global TOKENS\\n\\n for token_id in tokens:\\n\\n if token_id not in TOKENS:\\n TOKENS[token_id] = {}\\n\\n if isinstance(tokens, dict):\\n token_info = tokens[token_id]\\n if token_info is None:\\n token_info = {}\\n\\n alias = token_info.get(\\\"alias\\\")\\n if alias is not None:\\n TOKENS[token_id][\\\"alias\\\"] = alias\\n\\n decimals = token_info.get(\\\"decimals\\\")\\n if decimals is not None:\\n TOKENS[token_id][\\\"decimals\\\"] = decimals\",\n \"def intern_documents(documents: Dict[str, List[List[str]]], word_interner: Dict[str, int], unk_token: str):\\n ret = dict()\\n unk = word_interner[unk_token]\\n for docid, sentences in documents.items():\\n ret[docid] = [[word_interner.get(w, unk) for w in s] for s in sentences]\\n return ret\",\n \"def update_existing(doc_data_tples):\\n def per_doc(doc, data_tples):\\n def per_field(data_tple):\\n field, datas = data_tple\\n map(_do_append_field(doc, field), datas)\\n map(per_field, data_tples)\\n return doc\\n\\n __docs = ( (per_doc(doc, data_tples), data_tples) for doc,data_tples in doc_data_tples )\\n return __docs\",\n \"def updateDocumentAll(self, documents):\\n docs = []\\n for document in documents:\\n if isinstance(document, couch.Document):\\n document = document.getData()\\n\\n # these are required params\\n if \\\"_id\\\" not in document or \\\"_rev\\\" not in document:\\n raise Exception(\\\"Both _id & _rev fields are required!\\\")\\n\\n docs.append(document)\\n\\n return self.client.post(self.name +\\\"/_bulk_docs\\\", None,\\n {\\\"docs\\\": docs}).getBodyData()\",\n \"def update_from_document(self, document_path):\\n with open(document_path, 'r') as document_file:\\n for sentence in document_file:\\n words = sentence.strip().split()\\n for word in words:\\n self._add_new_word(word)\",\n \"def preprocess(self, documents):\\n\\n # A dict storing the frequency of each word\\n word_freq = {}\\n\\n # Iterate for each document\\n for doc in documents:\\n # Split the document into a list of words and iterate on it\\n for w in extract_words(doc):\\n # Update word frequencies\\n '''YOUR CODE HERE'''\\n if w not in word_freq.keys():\\n word_freq[w] = 1\\n else:\\n word_freq[w] += 1\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n\\n # A set of words with frequency less than 'self.min_freq'\\n remove_words = set()\\n\\n # Check frequency of each word and add to 'remove_words'\\n # if it's frequency is below self.min_freq\\n\\n ''' YOUR CODE HERE '''\\n for w in word_freq.keys():\\n if word_freq[w] < self.min_freq:\\n remove_words.add(w)\\n\\n # Delete the words in 'remove_words' from 'word_freq'\\n for w in remove_words:\\n del word_freq[w]\\n\\n # Fill 'self.word_to_idx' and 'self.idx_to_word' for\\n # each word in 'word_freq' (dicts are explained above)\\n\\n i = 0\\n for w in word_freq.keys():\\n self.word_to_idx[w] = i\\n self.idx_to_word[i] = w \\n i += 1\\n\\n ''' END YOUR CODE HERE '''\",\n \"def fit(self, documents):\\n # Get a list of all the unique tokens that appear\\n vocab = list({\\n token for doc in documents\\n for token in self.tokenizer(doc)\\n if token not in self._word2index\\n })\\n\\n # This is UNK, START, END, and PAD.\\n nb_special_tokens = 4\\n\\n # First, we map token -> ID, leaving the first slots for special tokens\\n self._word2index.update({\\n word: idx\\n for idx, word in enumerate(vocab, nb_special_tokens)\\n })\\n\\n # Next, we invert this map, which we can do since it was built from\\n # unique vocabulary elements and is by definition bijective.\\n self._index2word.update({\\n idx: word\\n for word, idx in self._word2index.items()\\n })\\n\\n return self\",\n \"def multiple_document_processing(self) -> List:\\n batch_list = []\\n for doc, idx in self.__documents:\\n entities_idx = {'idx': idx}\\n entities_result = self.create_entity(document=doc)\\n word_cleaned = self.clean_words(doc)\\n entities_idx[self.key_spacy_text] = str(word_cleaned)\\n entities_idx.update(entities_result)\\n batch_list.append(entities_idx)\\n return batch_list\",\n \"def get_doc_dicts(self, doc_ids):\\n pass\",\n \"def updateMultipleDocuments(cred, payload):\\n\\n url = cred.base_url + \\\"documents:commit\\\"\\n data = { 'writes': [] }\\n\\n for path, fieldData in payload.iteritems():\\n pathData = createFirestoreDataObject(cred, path, fieldData)\\n data['writes'].append(pathData)\\n \\n makeRequest(cred, url, 'POST', data)\",\n \"def add_doc_in_posting_list(word_posting_list, docs):\\n for doc_score in docs:\\n if doc_score[\\\"doc\\\"] in word_posting_list.keys():\\n word_posting_list[doc_score[\\\"doc\\\"]] = int(doc_score[\\\"score\\\"]) + int(word_posting_list[doc_score[\\\"doc\\\"]])\\n else:\\n word_posting_list[doc_score[\\\"doc\\\"]] = doc_score[\\\"score\\\"]\",\n \"def load(self, documents, uniquify=False):\\n assert documents, \\\"missing list of documents, text single doc per line\\\"\\n assert isinstance(documents, list), \\\"documents must be list\\\"\\n assert isinstance(documents[0], list), \\\"each document is also a list\\\"\\n #--------------------------------------------------------------------------------------------\\n\\n def _get_new_counts(document):\\n return Counter(document) if not uniquify else Counter(list(set(document)))\\n\\n for idx, document in enumerate(documents):\\n new_counter = _get_new_counts(document)\\n self.counter.update(new_counter)\\n if idx % 1000 == 0:\\n print(\\\"load: {}\\\\r\\\".format(idx), end='')\\n return self\",\n \"def parse_doc(self, doc_as_list):\\n\\n tweet_id = doc_as_list[0]\\n tweet_date = doc_as_list[1]\\n full_text = doc_as_list[2]\\n url = doc_as_list[3]\\n indice = doc_as_list[4]\\n retweet_text = doc_as_list[5]\\n retweet_url = doc_as_list[6]\\n retweet_indice = doc_as_list[7]\\n quote_text = doc_as_list[8]\\n quote_url = doc_as_list[9]\\n quoted_indice = doc_as_list[10]\\n retweet_quoted_text = doc_as_list[11]\\n retweet_quoted_url = doc_as_list[12]\\n retweet_quoted_indice = doc_as_list[13]\\n\\n term_dict = {}\\n\\n tokenized_text = self.parse_sentence(full_text)\\n tokenized_quote = self.parse_sentence(quote_text)\\n # tokenized_url = self.handle_url(url)\\n\\n\\n doc_length = len(tokenized_text) # after text operations - length of full_text\\n\\n new_tokenized_text = tokenized_text + tokenized_quote\\n\\n # spell checker\\n # new_tokenized_text = self.spell.update(new_tokenized_text)\\n\\n for term in new_tokenized_text:\\n if term is not \\\"\\\": # or (term.isalpha() and len(term) == 1)\\n if term not in term_dict:\\n term_dict[term] = 1\\n else:\\n term_dict[term] += 1\\n\\n document = Document(tweet_id, tweet_date, full_text, url, retweet_text, retweet_url, quote_text,\\n quote_url, term_dict, doc_length)\\n return document\",\n \"def prepare_dictionary_from_docs(self):\\n if os.path.exists(self.DICT_PATH):\\n return True\\n self.logger.info(\\\"START PREPARING DICT\\\")\\n for fn in os.listdir(self.wiki_path):\\n self.logger.info(\\\"dict update {0}\\\".format(fn))\\n content = self.get_processed_content(fn)\\n self.dictionary.add_documents([content])\\n self.dictionary.filter_extremes(no_below=20, no_above=0.1, keep_n=100000)\\n self.dictionary.compactify()\\n self.dictionary.save(self.DICT_PATH)\\n return True\",\n \"def get_dict(cleaned_docs):\\n data = []\\n for doc in cleaned_docs:\\n data += doc\\n return list(set(data))\",\n \"def transform(self, docs):\\n return [doc for doc in docs]\",\n \"def doc2bow(self, document, allow_update=False, return_missing=False):\\n\\n doc=[t.text for t in document.tokens]\\n\\n if isinstance(doc, string_types):\\n raise TypeError(\\\"doc2bow expects an array of unicode tokens on input, not a single string\\\")\\n\\n # Construct (word, frequency) mapping.\\n counter = defaultdict(int)\\n for w in doc:\\n counter[w if isinstance(w, str) else str(w, 'utf-8')] += 1\\n\\n token2id = self.token2id\\n if allow_update or return_missing:\\n missing = sorted(x for x in iteritems(counter) if x[0] not in token2id)\\n if allow_update:\\n for w, _ in missing:\\n # new id = number of ids made so far;\\n # NOTE this assumes there are no gaps in the id sequence!\\n token2id[w] = len(token2id)\\n result = {token2id[w]: freq for w, freq in iteritems(counter) if w in token2id}\\n\\n if allow_update:\\n self.num_docs += 1\\n self.num_pos += sum(itervalues(counter))\\n self.num_nnz += len(result)\\n # keep track of document and collection frequencies\\n for tokenid, freq in iteritems(result):\\n self.cfs[tokenid] = self.cfs.get(tokenid, 0) + freq\\n self.dfs[tokenid] = self.dfs.get(tokenid, 0) + 1\\n\\n # return tokenids, in ascending id order\\n result = sorted(iteritems(result))\\n if return_missing:\\n return result, dict(missing)\\n else:\\n return result\",\n \"def _build_token_dict(self, corpus: List[List[str]]):\\n self.token2idx = self.load_from_vocab_file(self.vocab_path)\\n self.idx2token = dict([(value, key)\\n for key, value in self.token2idx.items()])\\n logging.debug(f\\\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\\\")\\n self.dataset_info['token_count'] = len(self.token2idx)\",\n \"def docs2ids(self):\\n self.docs = [ [self.vocab[word] for word in doc] for doc in self.docs]\",\n \"def update_all(cls, documents: List[dict]) -> (List[dict], List[dict]):\\n if not documents:\\n raise ValidationFailed([], message=\\\"No data provided.\\\")\\n\\n if not isinstance(documents, list):\\n raise ValidationFailed(documents, message=\\\"Must be a list.\\\")\\n\\n new_documents = copy.deepcopy(documents)\\n\\n errors = cls.validate_and_deserialize_update(new_documents)\\n if errors:\\n raise ValidationFailed(documents, errors)\\n\\n try:\\n if cls.logger.isEnabledFor(logging.DEBUG):\\n cls.logger.debug(f\\\"Updating {new_documents}...\\\")\\n previous_documents, updated_documents = cls._update_many(new_documents)\\n if cls.logger.isEnabledFor(logging.DEBUG):\\n cls.logger.debug(f\\\"Documents updated to {updated_documents}.\\\")\\n return (\\n [cls.serialize(document) for document in previous_documents],\\n [cls.serialize(document) for document in updated_documents],\\n )\\n except pymongo.errors.DuplicateKeyError:\\n raise ValidationFailed(\\n [cls.serialize(document) for document in documents],\\n message=\\\"One document already exists.\\\",\\n )\",\n \"def load_documents(data_dir: str, docids: Set[str] = None) -> Dict[str, List[List[str]]]:\\n if os.path.exists(os.path.join(data_dir, 'docs.jsonl')):\\n assert not os.path.exists(os.path.join(data_dir, 'docs'))\\n return load_documents_from_file(data_dir, docids)\\n\\n docs_dir = os.path.join(data_dir, 'docs')\\n res = dict()\\n if docids is None:\\n docids = sorted(os.listdir(docs_dir))\\n else:\\n docids = sorted(set(str(d) for d in docids))\\n for d in docids:\\n with open(os.path.join(docs_dir, d), 'r') as inf:\\n lines = [l.strip() for l in inf.readlines()]\\n lines = list(filter(lambda x: bool(len(x)), lines))\\n tokenized = [list(filter(lambda x: bool(len(x)), line.strip().split(' '))) for line in lines]\\n res[d] = tokenized\\n return res\",\n \"def load_documents_from_file(data_dir: str, docids: Set[str] = None) -> Dict[str, List[List[str]]]:\\n docs_file = os.path.join(data_dir, 'docs.jsonl')\\n documents = load_jsonl(docs_file)\\n documents = {doc['docid']: doc['document'] for doc in documents}\\n res = dict()\\n if docids is None:\\n docids = sorted(list(documents.keys()))\\n else:\\n docids = sorted(set(str(d) for d in docids))\\n for d in docids:\\n lines = documents[d].split('\\\\n')\\n tokenized = [line.strip().split(' ') for line in lines]\\n res[d] = tokenized\\n return res\",\n \"def initialize_terms_and_postings():\\n global dictionary, postings\\n for id in document_filenames:\\n document = getDocumentContent(document_filenames[id])\\n if(document_filenames[id].rfind(\\\".pdf\\\") == len(document_filenames[id]) - 4):\\n terms = tokenize(document.encode('utf-8'))\\n if(document_filenames[id].rfind(\\\".txt\\\") == len(document_filenames[id]) - 4):\\n terms = tokenize(document)\\n if(document_filenames[id].rfind(\\\".docx\\\") == len(document_filenames[id]) - 5):\\n terms = tokenize(document)\\n if(document_filenames[id].rfind(\\\".pptx\\\") == len(document_filenames[id]) - 5):\\n terms = tokenize(document)\\n unique_terms = set(terms)\\n dictionary = dictionary.union(unique_terms)\\n for term in unique_terms:\\n postings[term][id] = terms.count(term) # the value is the\\n # frequency of the\\n # term in the\\n # document\",\n \"def _create_dictionary(self, document_set):\\n words = self._normalize_words(document_set.words)\\n unique_words = frozenset(words)\\n return dict((word, idx) for idx, word in enumerate(unique_words))\",\n \"def set_keyword_map(self):\\n \\n ret = defaultdict(list)\\n for idx, doc in enumerate(self.docs):\\n for token in doc:\\n if token in self.dictionary.token2id:\\n ret[token].append(idx)\\n \\n self.keyword_map = ret\\n return ret\",\n \"def clean_docs(self,docs):\\n\\n # Remove numbers, but not words that contain numbers.\\n docs = [[token for token in doc if not token.isnumeric()] for doc in docs]\\n\\n # Remove words that are only one character.\\n docs = [[token for token in doc if len(token) > 1 and token not in stop_words] for doc in docs]\\n\\n # lemmatizer = WordNetLemmatizer()\\n # docs = [[lemmatizer.lemmatize(token) for token in doc] for doc in docs]\\n\\n # Add bigrams and trigrams to docs (only ones that appear 20 times or more).\\n bigram = Phrases(docs, min_count=20)\\n for idx in range(len(docs)):\\n for token in bigram[docs[idx]]:\\n if '_' in token:\\n # Token is a bigram, add to document.\\n docs[idx].append(token)\\n\\n # Create a dictionary representation of the documents.\\n dictionary = Dictionary(docs)\\n\\n # Filter out words that occur less than 20 documents, or more than 50% of the documents.\\n dictionary.filter_extremes(no_below=20, no_above=0.5)\\n\\n # Bag-of-words representation of the documents.\\n corpus = [dictionary.doc2bow(doc) for doc in docs]\\n\\n return docs,dictionary,corpus\",\n \"def add_new_doc(self, document, documents_list_length=10000):\\n\\n try:\\n document_dictionary = document.term_doc_dictionary\\n # self.countDoc += 1\\n for term in document_dictionary.keys():\\n if self.stemming == 'y':\\n my_stemmer = Stemmer()\\n term = my_stemmer.stem_term(term)\\n # Update inverted index and posting\\n if term not in self.inverted_idx.keys():\\n self.inverted_idx[term] = [1, [\\n (document_dictionary[term], document.tweet_id)]] # amount of doc, freq in the doc, doc id.\\n\\n else:\\n self.inverted_idx[term][0] += 1 # amount of doc\\n self.inverted_idx[term][1].append((document_dictionary[term],\\n document.tweet_id)) # freq in the doc # doc id\\n\\n if term not in self.postingDict.keys():\\n self.postingDict[term] = [(document.tweet_id, document_dictionary[term])]\\n else:\\n self.postingDict[term].append((document.tweet_id, document_dictionary[term]))\\n # self.countTweet -= 1\\n\\n if document.tweet_id not in self.tweet_dict.keys():\\n self.tweet_dict[document.tweet_id] = [[term, document_dictionary[term]], 1,\\n 0] # [term,freq in tweet], amount of unique terms in tweet, amount of terms in tweet\\n elif document_dictionary[term] > self.tweet_dict[document.tweet_id][0][\\n 1]: # tweet exist, compering between freq in two terms\\n if self.tweet_dict[document.tweet_id][0][\\n 1] == 1: # before change term check if the last term is unique\\n self.tweet_dict[document.tweet_id][\\n 1] += 1 # last term is unique: add to the amount of uniqe terms in tweet\\n self.tweet_dict[document.tweet_id][0] = [term,\\n document_dictionary[term]] # change between the terms\\n self.tweet_dict[document.tweet_id][2] += 1\\n elif document_dictionary[term] == 1: # tweet exist, not most common, check if unique\\n self.tweet_dict[document.tweet_id][1] += 1\\n self.tweet_dict[document.tweet_id][2] += 1\\n except:\\n # print('problem in indexer : add_new_doc')\\n # print(traceback.print_exc())\\n pass\",\n \"def add(self, document):\\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\\n if not token.isalpha():\\n continue\\n\\n if token in self.stopwords:\\n continue\\n \\n if self.stemmer:\\n token = self.stemmer.stem(token)\\n \\n if self.__unique_id not in self.index[token]:\\n self.index[token].append(self.__unique_id)\\n \\n self.documents[self.__unique_id] = document\\n self.__unique_id += 1\",\n \"def preprocess(self, documents):\\n\\n # Store the total number of documents\\n num_docs = np.float(len(documents))\\n\\n # A dict storing the frequency of each word across all documents\\n total_word_freq = {}\\n\\n # A dict storing the number of documents that word appears in\\n doc_word_freq = {}\\n\\n # Iterate over all documents\\n for doc in documents:\\n # Split the string into a list of words\\n words = extract_words(doc)\\n\\n # Update the 'total_word_freq' dict using all words in 'words'\\n for w in words:\\n ''' YOUR CODE HERE '''\\n if w not in total_word_freq.keys():\\n total_word_freq[w] = 1\\n else:\\n total_word_freq[w] += 1\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n # Update the 'doc_word_freq' dict. Remember to only add '1' corresponding to\\n # each word in a document. In case a word appears twice in a document, then\\n # it should be ignored. We use the set() data structure to achieve this.\\n for w in set(words):\\n ''' YOUR CODE HERE '''\\n if w not in doc_word_freq:\\n doc_word_freq[w] = 1\\n else:\\n doc_word_freq[w] += 1\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n # A set of words with total frequency less than 'self.min_freq'\\n remove_words = set()\\n\\n ''' YOUR CODE HERE '''\\n\\n # Check frequency of each word and add to 'remove_words'\\n for w in total_word_freq.keys():\\n if total_word_freq[w] < self.min_freq:\\n remove_words.add(w)\\n\\n # Delete the words in 'remove_words' from 'total_word_freq' and\\n # 'doc_word_freq'.\\n for w in remove_words:\\n del total_word_freq[w]\\n del doc_word_freq[w]\\n\\n # Create a numpy array to store frequencies from which\\n # we can create the 'self.idf' preprocessed numpy array.\\n word_freq_tensor = np.zeros(len(doc_word_freq))\\n\\n # For each word in 'doc_word_freq' dict, update\\n # 'self.word_to_idx' and 'self.idx_to_word' and\\n # 'word_freq_tensor'.\\n i = 0\\n for w in doc_word_freq.keys():\\n self.word_to_idx[w] = i \\n self.idx_to_word[i] = w\\n word_freq_tensor[i] = doc_word_freq[w]\\n i+=1\\n \\n #print(word_freq_tensor.shape)\\n #print(word_freq_tensor)\\n # Calculate 'self.idf' (see hint.pdf for formula)\\n self.idf = -1*np.log(word_freq_tensor/(len(documents)))\\n ''' END YOUR CODE HERE '''\",\n \"def process_new_tokens(tokens,processed_tokens_set, model, dictionary):\\n if hasattr(model, 'using_pretrained') and model.using_pretrained is not None:\\n processed_tokens_set.update(tokens)\\n update_embedding_layer(processed_tokens_set, model, dictionary)\",\n \"def process_document(text):\\n words = preprocess(text)\\n postings = {}\\n for word, ix in words:\\n if word in postings:\\n wordinfo = postings[word]\\n else:\\n wordinfo = {\\\"frequency\\\": 0, \\\"indexes\\\": []}\\n postings[word] = wordinfo\\n wordinfo[\\\"frequency\\\"] += 1\\n wordinfo[\\\"indexes\\\"].append(ix)\\n return postings\",\n \"def pre_process(self, documents):\\n\\n return documents\",\n \"def insert_many(self, documents: Iterable[dict]) -> None:\\n for i, document in enumerate(documents):\\n if isinstance(document, dict):\\n self._store_document(document)\\n else:\\n raise TypeError(\\n f\\\"The document at index {i} was not a dictionary. All documents must be dictionaries.\\\"\\n )\\n self._dump()\",\n \"def _docMapping(self):\\n doc2quests = defaultdict(list)\\n for q, d in self.quest2doc.items():\\n doc2quests[d].append(q)\\n return doc2quests\",\n \"def create_document_dictionary(documents):\\n \\n document_dictionary = dict()\\n for document in documents:\\n document_dictionary[document.cord_uid] = document\\n return document_dictionary\",\n \"def transform4Doc2Vec(docs):\\n\\n # transform documents to be used by doc2Vec\\n documents = []\\n analyzedDocument = namedtuple('AnalyzedDocument', 'words tags')\\n for i, doc in enumerate(docs):\\n # use first line if documents are not tokenized, otherwise next line\\n # words = text.lower().split()\\n tags = [i]\\n documents.append(analyzedDocument(doc, tags))\\n\\n return documents\",\n \"def _create_dictionary(self, document):\\n words = self._normalize_words(document.words)\\n unique_words = frozenset(words)\\n return dict((word, idx) for idx, word in enumerate(unique_words))\",\n \"def enrich(self, lazy_corpus_loader, fileids=None):\\n tag_dict = self.tag_dict\\n word_tag_dict = self.word_tag_dict\\n for word_tag in lazy_corpus_loader.tagged_words(fileids=fileids):\\n word = word_tag[0]\\n tag = word_tag[1]\\n if not tag_dict.get(tag, None):\\n raise KeyError, \\\"Unknown pos-tag: %s\\\" % tag\\n tag_dict = word_tag_dict.get(word, {})\\n tag_dict[tag] = tag_dict.get(tag, 0) + 1\\n word_tag_dict[word] = tag_dict\\n self.word_tag_dict = word_tag_dict\",\n \"def add(self, tokens):\\n\\n for token in tokens:\\n self.vocab.add(token)\\n\\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\\n if leader not in self.frequencies:\\n self.frequencies[leader] = Frequency()\\n\\n self.frequencies[leader].add(token)\",\n \"def set_doc_phrases(doc_phrases, docs, phrases):\\n for doc in docs:\\n if not doc in doc_phrases:\\n doc_phrases[doc] = []\\n doc_phrases[doc] = doc_phrases[doc] + phrases\",\n \"def tokenize_document(doc_info: dict, tokenizer: BertTokenizer, max_doc_length: int = None) -> dict:\\n sub_tokens: List[str] = [] # all sub tokens of a document\\n sentence_map: List[int] = [] # collected tokenized tokens -> sentence id\\n subtoken_map: List[int] = [] # collected tokenized tokens -> original token id\\n\\n word_idx = -1\\n\\n for sentence_id, sentence in enumerate(doc_info['sentences']):\\n for token in sentence:\\n word_idx += 1\\n word_tokens = tokenizer.tokenize(token)\\n sub_tokens.extend(word_tokens)\\n sentence_map.extend([sentence_id] * len(word_tokens))\\n subtoken_map.extend([word_idx] * len(word_tokens))\\n if max_doc_length:\\n num_to_pad = max_doc_length - len(sub_tokens)\\n sub_tokens.extend([\\\"[PAD]\\\"] * num_to_pad)\\n sentence_map.extend([sentence_map[-1]+1] * num_to_pad)\\n subtoken_map.extend(list(range(word_idx+1, num_to_pad+1+word_idx)))\\n # global MAX_LENGTH\\n # if len(sub_tokens) > MAX_LENGTH:\\n # print(len(sub_tokens))\\n # MAX_LENGTH = len(sub_tokens)\\n # print(MAX_LENGTH)\\n # todo(yuxian): need pad speakers?\\n speakers = {subtoken_map.index(word_index): tokenizer.tokenize(speaker)\\n for word_index, speaker in doc_info['speakers']}\\n clusters = [[(subtoken_map.index(start), len(subtoken_map) - 1 - subtoken_map[::-1].index(end))\\n for start, end in cluster] for cluster in doc_info['clusters']]\\n tokenized_document = {'sub_tokens': sub_tokens, 'sentence_map': sentence_map, 'subtoken_map': subtoken_map,\\n 'speakers': speakers, 'clusters': clusters, 'doc_key': doc_info['doc_key']}\\n return tokenized_document\",\n \"def replace_words_fun(self):\\n\\n cleaned_doc = []\\n for word in str(self.doc).split():\\n if word.lower() in self.replacement_list.keys():\\n cleaned_doc.append(self.replacement_list[word.lower()])\\n else:\\n cleaned_doc.append(word)\\n self.doc = ' '.join(cleaned_doc)\",\n \"def get_idf_dict(clean_corpus, tf_list, num_docs):\\n \\n idf_dict = {}\\n for i in range(num_docs):\\n for key in tf_list[i].keys():\\n if key not in idf_dict.keys():\\n idf_dict[key] = 0\\n idf_dict[key] = idf_dict[key] + 1\\n \\n for key in idf_dict.keys():\\n idf_dict[key] = math.log2(num_docs/idf_dict[key])\\n # idf_dict's keys -> all unique tokens in the corpus \\n return idf_dict\",\n \"def initialize_document_frequencies():\\n global document_frequency\\n for term in dictionary:\\n document_frequency[term] = len(postings[term])\",\n \"def preprocess_corpus(corpus, stop_list, stop_words=True, stemm=True, bag_words=True):\\n corpus_preprocessed = list()\\n for element in corpus:\\n new_element = dict()\\n new_element['document'] = preprocess_document(element['text'], stop_list, stop_words, stemm, bag_words)\\n new_element['id'] = element['id']\\n corpus_preprocessed.append(new_element)\\n\\n return corpus_preprocessed\",\n \"def create_tokens_li():\\n cnt=0\\n for file in docs:\\n file_name = open(\\\"./corpus/\\\"+ str(file) + \\\".txt\\\")\\n print(cnt)\\n cnt+=1\\n words = file_name.read()\\n tokens_doc = nltk.word_tokenize(words)\\n tokens_doc = [w.lower() for w in tokens_doc]\\n #tokens_doc = [snowball_stemmer.stem(token) for token in tokens_doc]\\n tokens_doc = [token for token in tokens_doc if token not in nltk.corpus.stopwords.words('english')]\\n tokens_li.append(tokens_doc)\\n\\n\\n #storing in json file\\n with open('savers/tokens.json', 'w') as fp:\\n json.dump(tokens_li, fp)\",\n \"def documents(self, documents):\\n\\n self._documents = documents\",\n \"def documents_to_dict(documents: List[Dict]) -> Dict[str, Dict]:\\n res = {}\\n for doc in documents:\\n res[doc['id']] = doc\\n return res\",\n \"def map_docs(docs_file):\\n word_map = defaultdict(int)\\n doc_count = 0\\n token_count = 0\\n\\n for _, doc_tokens in tokenize(docs_file):\\n doc_count += 1 # count document\\n token_count += len(doc_tokens) # count tokens\\n for token in set(doc_tokens):\\n word_map[token] += 1 # increase inverted index count\\n\\n docs_file.seek(0) # reset file pointer\\n return doc_count, token_count, word_map\",\n \"def updateScores(rankedLists):\\n docToRank = {}\\n for rankedList in rankedLists:\\n\\n f = open(rankedList, 'r')\\n for line in f:\\n documentID = line.split()[2]\\n docno = documentID\\n score = float(line.split()[4])\\n position = int(line.split()[3])\\n docToRank[docno] = (position,score)\\n f.close()\\n client = MongoClient('asr2.iem.technion.ac.il',27017)\\n db = client.asr16\\n documents = db.documents.find({})\\n for document in documents:\\n key = document[\\\"query_id\\\"]+\\\"-\\\"+document[\\\"username\\\"]\\n document['position'] = docToRank[key][0]\\n document['score'] = docToRank[key][1]\\n document['posted_document'] = document['current_document']\\n db.documents.save(document)\",\n \"def merge_docs(self):\",\n \"def run(self, mapping={}, *args, **kwargs):\\n self.processed = 0\\n for batch in self._process_by_batch(self.load(*args, **kwargs)):\\n batch = list(map(lambda doc: self._apply_mapping(doc, mapping), batch))\\n for doc in batch:\\n self._ingest(iterable=doc, doctype=doc[\\\"doctype\\\"])\\n self.processed += 1\\n logger.info(\\\"Added {} documents to the database.\\\".format(self.processed))\",\n \"def make_vocab_from_docs(docs):\\n vocab_words=set()\\n for doc in docs:\\n doc=doc.lower()\\n doc=re.sub(r'-',' ',doc)\\n doc=re.sub(r' +',' ',doc) # turn multiple spaces into a single space\\n doc=re.sub(r'[^a-z ]','',doc) # remove anything that is not a-z or space\\n words=set(doc.split())\\n vocab_words=vocab_words.union(words)\\n vocab=dict(zip(vocab_words,range(len(vocab_words))))\\n return vocab\",\n \"def _prepare_analysis_input(self, documents):\\n subdoc_to_doc_map = {}\\n wordtype_to_number = {}\\n number_to_wordtype = []\\n wordtypes = {}\\n \\n # prevent duplicating work\\n if os.path.exists(self.wordtype_file):\\n return\\n \\n try:\\n # First find singletons\\n if self.remove_singletons:\\n word_type_count_threshold = max(1, int(math.log(documents.count(), 10)) - 2)\\n temp_word_type_counts = {}\\n for doc_index, doc in enumerate(documents):\\n tokens = self.tokenize(doc.get_content())\\n for token, token_start in tokens:\\n temp_word_type_counts[token] = temp_word_type_counts.setdefault(token, 0) + 1\\n for word_type, count in temp_word_type_counts.iteritems(): # add singletons to stopword list\\n if count <= word_type_count_threshold:\\n self._excluded_words[word_type] = True\\n with io.open(self.excluded_words_file, 'w', encoding='utf-8') as ex_f:\\n ex_f.write(unicode(json.dumps(self._excluded_words)))\\n \\n haltwords = dict(self.stopwords)\\n haltwords.update(self._excluded_words)\\n # Second find bigrams, iterate through documents and train.\\n if self.find_bigrams:\\n from import_tool.analysis.bigram_finder import BigramFinder\\n bigram_finder = BigramFinder(stopwords=haltwords)\\n for doc_index, doc in enumerate(documents):\\n bigram_finder.train(doc_index, self.tokenize(doc.get_content()))\\n bigram_finder.print()\\n \\n # Third, we're going to stem words\\n if self.stem_words:\\n from import_tool.analysis.stemmer import Stemmer\\n stemmer = Stemmer(self._working_dir, self.base_dir)\\n \\n # for each document tokenize and map tokens to numbers to avoid regex problems before passing data to Mallet\\n with io.open(self.mallet_input_file, 'w', encoding='utf-8') as w:\\n with io.open(self.start_index_file, 'w', encoding='utf-8') as w2:\\n count = 0\\n subcount = 0\\n for doc_index, doc in enumerate(documents):\\n doc_content = unicode(doc.get_content())\\n count += 1\\n subdocuments = self.create_subdocuments(doc_index, doc_content)\\n token_start_index_offset = 0 # needed to make sure the start index remains correct once the document is re-merged\\n for subdoc_name, subdoc_content in subdocuments:\\n if subcount > 0:\\n w2.write(u'\\\\n')\\n subcount += 1\\n subdoc_to_doc_map[subdoc_name] = doc_index\\n tokens = self.tokenize(subdoc_content)\\n \\n if self.find_bigrams:\\n tokens = bigram_finder.combine(tokens, subdoc_content)\\n \\n token_numbers = []\\n token_start_indices = []\\n only_tokens = []\\n tokens_temp = []\\n for tok, tok_start in tokens:\\n only_tokens.append(tok)\\n tokens_temp.append([tok, tok_start + token_start_index_offset])\\n tokens = tokens_temp\\n tokens_temp = None\\n if self.stem_words:\\n stemmed_tokens = stemmer.stem(only_tokens)\\n else:\\n stemmed_tokens = only_tokens\\n for tup, tok_stem in zip(tokens, stemmed_tokens):\\n tok, tok_start = tup\\n wordtypes[tok] = True\\n wordtypes[tok_stem] = True\\n try:\\n tok_num = wordtype_to_number[tok_stem]\\n except:\\n tok_num = len(wordtype_to_number)\\n number_to_wordtype.append(tok_stem)\\n wordtype_to_number[tok_stem] = tok_num\\n token_numbers.append(unicode(tok_num))\\n token_start_indices.append([tok, tok_start])\\n text = u' '.join(token_numbers)\\n w.write(u'{0} all {1}\\\\n'.format(subdoc_name, text))\\n w2.write(unicode(json.dumps(token_start_indices)))\\n token_start_index_offset += len(subdoc_content)\\n for tok, tok_start in tokens:\\n try:\\n assert doc_content[tok_start:tok_start+len(tok)].lower() == tok.lower()\\n except:\\n print(tok_start)\\n print(len(tok))\\n print('\\\"'+doc_content[tok_start:tok_start+len(tok)].lower()+'\\\"')\\n print('\\\"'+tok.lower()+'\\\"')\\n raise\\n if not count:\\n raise Exception('No files processed.')\\n # record which subdocuments belong to which documents\\n with io.open(self.subdoc_to_doc_map_file, 'w', encoding='utf-8') as w:\\n w.write(unicode(json.dumps(subdoc_to_doc_map)))\\n with io.open(self.wordtype_to_number_file, 'w', encoding='utf-8') as w:\\n w.write(unicode(json.dumps(wordtype_to_number)))\\n with io.open(self.number_to_wordtype_file, 'w', encoding='utf-8') as w:\\n w.write(unicode(json.dumps(number_to_wordtype)))\\n with io.open(self.wordtype_file, 'w', encoding='utf-8') as w:\\n w.write(unicode(json.dumps(wordtypes)))\\n except: # cleanup\\n self._cleanup(self.mallet_input_file)\\n self._cleanup(self.subdoc_to_doc_map_file)\\n self._cleanup(self.wordtype_to_number_file)\\n self._cleanup(self.number_to_wordtype_file)\\n self._cleanup(self.wordtype_file)\\n self._cleanup(self.excluded_words_file)\\n raise\",\n \"def current_word_PL(current_word, file_reader_last_read_list, doc_dict, nb_doc):\\n word_posting_list = {} # { key = doc , value = score }\\n for idx, file_reader_last_read in enumerate(file_reader_last_read_list):\\n if file_reader_last_read[\\\"last_read\\\"][\\\"word\\\"] == current_word:\\n docs = file_reader_last_read[\\\"last_read\\\"][\\\"doc_score_list\\\"]\\n add_doc_in_posting_list(word_posting_list=word_posting_list, docs=docs)\\n file_reader_last_read_list[idx]=read_line_and_update(file_reader_and_last_read=file_reader_last_read)\\n for key, value in word_posting_list.items():\\n tf = float(value) / doc_dict[int(key)]\\n idf = math.log((float(nb_doc)/len(word_posting_list)),2)\\n score = tf*idf\\n word_posting_list[key]=score \\n word_posting_list = sort_and_cast_doc_in_posting_list(word_posting_list=word_posting_list)\\n return word_posting_list\",\n \"async def put_documents(self, collection, documents):\\n await self.ensure_collection(collection)\\n try:\\n if SOLR_COMMIT_WITHIN:\\n params = {'commitWithin': SOLR_COMMIT_WITHIN}\\n else:\\n params = {'commit': 'true'}\\n await self.post(\\n '/v2/collections/{}/update'.format(collection),\\n params=params, json_data=documents\\n )\\n logger.info('Successfully indexed {} documents to collection {}'\\n .format(len(documents), collection))\\n except SolrError:\\n logger.warning('Failed to put {} documents to collection {}'\\n .format(len(documents), collection))\\n raise\",\n \"def from_documents(cls, documents):\\n # return cls.from_words(_itertools.chain(*documents))\\n return cls.from_words(\\n cls._build_new_documents(documents, cls.default_ws, pad_right=True)\\n )\",\n \"def add_new_doc(self, document, end_of_corpus):\\n max_tf = 0\\n unique_terms_counter = 0\\n document_dictionary = document.term_doc_dictionary\\n # Go over each term in the doc\\n for term in document_dictionary:\\n try:\\n # Update inverted index and posting\\n if term not in self.inverted_idx:\\n self.inverted_idx[term] = 1\\n unique_terms_counter += 1\\n else:\\n self.inverted_idx[term] += 1\\n if term not in self.posting_dict:\\n self.posting_dict[term] = []\\n\\n self.posting_dict[term].append(\\n (document.tweet_id, document_dictionary[term])) # key: str , value: array of tuples\\n\\n max_tf = max(document_dictionary[term], max_tf)\\n\\n except:\\n\\n print('problem with the following key {}'.format(term[0]))\\n\\n document.max_tf = max_tf\\n document.unique_terms = unique_terms_counter\\n self.docs_count += 1\\n\\n modulo = int(document.tweet_id) % 10\\n self.documents[modulo][document.tweet_id] = [document.term_doc_dictionary, document.max_tf]\\n\\n if self.docs_count == self.DOCS_SIZE or end_of_corpus: # if we reach chunk size or end of corpus\\n self.add_to_file(end_of_corpus)\\n self.docs_count = 0\\n self.posting_dict = {}\\n\\n for i in self.documents: # 0 - 9\\n if self.documents[i].__len__() > 15000:\\n doc = utils.load_obj(self.out + \\\"document\\\" + str(i))\\n doc.update(self.documents[i])\\n utils.save_obj(doc, self.out + \\\"document\\\" + str(i))\\n self.documents[i] = {}\",\n \"def upload(self, documents: List[Document], vectorise_func) -> None:\\n\\n # Add doc_store to documents\\n for d in documents:\\n d.doc_store = self\\n # Check ID uniqueness\\n check_duplicate_documents(documents)\\n # Check type consistency\\n check_document_types(documents)\\n # Batching\\n batches = batch_items(documents)\\n\\n # Update document class conveniently\\n if issubclass(type(documents[0]), ChunkedDocument):\\n self._doc_class = ChunkedDocument\\n\\n for batch in batches:\\n vectorise_func(batch, self)\\n self.documents += batch\",\n \"def add_doc(self, document):\\n # Split document up into list of strings\\n #words = self.tokenize(document)\\n words = document\\n # Count word frequencies in this document\\n word_counts = {}\\n for word in words:\\n word_counts[word] = word_counts.get(word, 0) + 1\\n # Add word counts as new row to sparse matrix\\n self.sparse.append(word_counts)\\n # Add to total document count for each word\\n for word in word_counts:\\n self.doc_count[word] = self.doc_count.get(word, 0) + 1\",\n \"def _merge_conllu_subtokens(self, lines: List[str], doc: Doc)-> Doc:\\n # identify and process all subtoken spans to prepare attrs for merging\\n subtok_spans = []\\n for line in lines:\\n parts = line.split(\\\"\\\\t\\\")\\n id_, word, lemma, pos, tag, morph, head, dep, _1, misc = parts\\n if \\\"-\\\" in id_:\\n subtok_start, subtok_end = id_.split(\\\"-\\\")\\n subtok_span = doc[int(subtok_start) - 1 : int(subtok_end)]\\n subtok_spans.append(subtok_span)\\n # create merged tag, morph, and lemma values\\n tags = []\\n morphs = {}\\n lemmas = []\\n for token in subtok_span:\\n tags.append(token.tag_)\\n lemmas.append(token.lemma_)\\n if token._.merged_morph:\\n for feature in token._.merged_morph.split(\\\"|\\\"):\\n field, values = feature.split(\\\"=\\\", 1)\\n if field not in morphs:\\n morphs[field] = set()\\n for value in values.split(\\\",\\\"):\\n morphs[field].add(value)\\n # create merged features for each morph field\\n for field, values in morphs.items():\\n morphs[field] = field + \\\"=\\\" + \\\",\\\".join(sorted(values))\\n # set the same attrs on all subtok tokens so that whatever head the\\n # retokenizer chooses, the final attrs are available on that token\\n for token in subtok_span:\\n token._.merged_orth = token.orth_\\n token._.merged_lemma = \\\" \\\".join(lemmas)\\n token.tag_ = \\\"_\\\".join(tags)\\n token._.merged_morph = \\\"|\\\".join(sorted(morphs.values()))\\n token._.merged_spaceafter = (\\n True if subtok_span[-1].whitespace_ else False\\n )\\n\\n with doc.retokenize() as retokenizer:\\n for span in subtok_spans:\\n retokenizer.merge(span)\\n\\n return doc\",\n \"def _apply_mapping(self, document, mapping):\\n if not mapping:\\n return document\\n new_document = {v: document[k] for k, v in mapping.items() if k in document}\\n # Keep track of missing keys\\n self.missing_keys.update([k for k in mapping if k not in document])\\n\\n # Document errors for missing documents\\n if not new_document:\\n self.failed += 1\\n self.failed_ids.append(\\n document.get(\\\"id\\\", document.get(\\\"ID\\\", document.get(\\\"_id\\\", None)))\\n )\\n return new_document\",\n \"def count_doc_frequencies(self, docs):\\n frequencyIndex = {}\\n doc_id = 0\\n for doc in docs:\\n for term in doc:\\n if term not in frequencyIndex:\\n frequencyIndex[term] = [doc_id]\\n else:\\n for id in frequencyIndex[term]:\\n if doc_id == id:\\n break\\n else:\\n frequencyIndex[term].append(doc_id)\\n doc_id+=1\\n\\n for term in frequencyIndex:\\n occurences = len(frequencyIndex[term])\\n frequencyIndex[term] = occurences\\n\\n return frequencyIndex\",\n \"def set_documents(cls, input_list_text: List[str]) -> None:\\n cls.documents = input_list_text\",\n \"def featurize(movies):\\n ###TODO \\n movies['features'] = \\\"\\\" \\n get_h = set() \\n vocab_dict = {}\\n df_dict_return = {}\\n tup_list = []\\n index_dict = {}\\n index_dict_1 = {}\\n movie_len = len(movies) \\n #print(\\\"MovieLength::\\\",movie_len)\\n #print(\\\"MOVIES:::\\\",movies)\\n \\n get_h = cal_unique_features(movies) # num_features\\n\\n vocab_dict = cal_unique_vocab(get_h) # vocab complete\\n\\n len_vocab = len(get_h)\\n \\n df_dict_return = cal_unique_docs(get_h,movies) # df(i)\\n\\n for token in get_h :\\n #tup_list.clear()\\n #print(\\\"token_GOTTTTT:::\\\",token)\\n for index,row in movies.iterrows(): \\n #print(\\\"row_got::\\\",row)\\n gen_list = row['tokens']\\n #print(\\\"gen_list::\\\",gen_list)\\n #mov_id = row['movieId'] \\n #print(\\\"mov_id::\\\",mov_id)\\n token_count_1 = Counter(gen_list).most_common()[:1]\\n tok = token_count_1[0]\\n index_dict_1[index] = tok[1]\\n token_count = gen_list.count(token)\\n #print(\\\"token_count::\\\",token_count)\\n tup = (index,token_count)\\n #print(\\\"tuple::\\\",tup)\\n tup_list.append(tup)\\n #print(\\\"LIST_PRINT:::::::::::::\\\",tup_list)\\n index_dict[token] = tup_list\\n tup_list = []\\n \\n \\n #print(\\\"INDEX_DICT:::\\\",index_dict) # tf(i,d)\\n #print(\\\"INDEX_DICT_1:::\\\",index_dict_1) # max_k dict per docx\\n \\n \\n for ind, row in movies.iterrows():\\n data_list = []\\n rows_list = []\\n columns_list = []\\n gen_list = row['tokens']\\n #print(\\\"TOKENS GOTTT::\\\",gen_list) \\n for gen in gen_list:\\n tf = get_tf_value(index_dict,gen,ind)\\n #print(\\\"TF GOTTT::\\\",tf) \\n tf_weight = float( tf / index_dict_1[ind])\\n #print(\\\"tf_weight::\\\",tf_weight)\\n df_weight = float( math.log10( movie_len / df_dict_return[gen] ) )\\n #print(\\\"df_weight::\\\",df_weight)\\n final_tfidf = tf_weight * df_weight\\n #print(\\\"final_tfidf::\\\",final_tfidf)\\n data_list.append(final_tfidf)\\n columns_list.append(vocab_dict[gen])\\n rows_list.append(0) \\n csr = csr_matrix((data_list, (rows_list,columns_list)), shape=(1,len_vocab))\\n #print(\\\"TYPE of CSR GOTT::\\\",type(csr))\\n #print(\\\"CSR GOTT:::\\\",csr) \\n movies.set_value(ind, 'features', csr)\\n \\n #print(\\\"UPDATE movies::\\\",movies) \\n\\n return(movies,vocab_dict)\\n \\n\\n pass\",\n \"def index_terms(self):\\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\\n self.doc_store.dict.iteritems()]\",\n \"def updateWordCounts():\\n emaildata = loadEmailData()\\n englishwords = importDictionary()\\n countAllWords(emaildata, englishwords)\",\n \"def set_document_numbers(notices):\\n\\n if len(notices) > 1:\\n for notice in notices:\\n notice['document_number'] = split_doc_num(\\n notice['document_number'], notice['effective_on'])\\n return notices\",\n \"def set_document_numbers(notices):\\n\\n if len(notices) > 1:\\n for notice in notices:\\n notice['document_number'] = split_doc_num(\\n notice['document_number'], notice['effective_on'])\\n return notices\",\n \"def update(self, docs: DocumentArray, *args, **kwargs):\\n cursor = self.connection.cursor()\\n psycopg2.extras.execute_batch(\\n cursor,\\n f'UPDATE {self.table} SET DOC = %s WHERE ID = %s',\\n [\\n (\\n doc.SerializeToString(),\\n doc.id,\\n )\\n for doc in docs\\n ],\\n )\\n self.connection.commit()\",\n \"def updateWordList(emailids):\\n with open('res/dictionary.txt', 'r') as f:\\n lines = f.readlines()\\n words = set([line.strip() for line in lines])\\n\\n with open('res/dictionary.txt', 'a') as f:\\n for emailid in emailids: \\n email = e.Email(emailid)\\n subject = set(email.parsedsubject)\\n body = set(email.body)\\n try:\\n emailcontent = body.union(subject)\\n for word in emailcontent:\\n if not word in words:\\n words.add(word)\\n f.write(word + '\\\\n')\\n except AttributeError:\\n print(body)\",\n \"def add_documents(self, docs):\\n for doc in docs:\\n assert isinstance(doc, pylastica.document.Document), \\\"All items in list docs must be of type Document: %r\\\" % doc\\n doc.doc_type = self.name\\n return self.index.add_documents(docs)\",\n \"def update_documents(self, engine_name, documents):\\n endpoint = \\\"engines/{}/documents\\\".format(engine_name)\\n data = json.dumps(documents)\\n\\n return self.swiftype_session.request('patch', endpoint, data=data)\",\n \"def create_freq_dict(corpus, doc_info):\\n for idx, content in enumerate(corpus):\\n word_freq_table = {}\\n splitted_sentence = content.split()\\n for word in splitted_sentence:\\n word = word.lower()\\n if word not in word_freq_table:\\n word_freq_table[word] = 1\\n else:\\n word_freq_table[word] += 1\\n doc_info[idx]['freq_dict'] = word_freq_table\",\n \"def index_feats_dict(self):\\n doc_features_dict = {}\\n\\n for index, doc in zip(self.index, self.series):\\n # Sets for a doc and feature words\\n doc_set = set(doc.split())\\n feat_set = set(self.features)\\n\\n # Shared words between the two sets\\n interset_words = doc_set.intersection(feat_set)\\n\\n # Append to doc_features_dict\\n doc_features_dict[index] = list(interset_words)\\n\\n return doc_features_dict\",\n \"def pos():\\n pos_list = []\\n for token in doc:\\n pos_list.append(token.pos_)\\n setList = list(set(pos_list))\\n my_dict = {i: pos_list.count(i) for i in setList}\\n print(my_dict)\",\n \"def finish_documents():\\n\\n doc_ids = json.loads(request.form['doc_ids'])\\n\\n for docid in doc_ids:\\n\\n document = Document.query.filter_by(id=docid).first_or_404()\\n\\n document.status = \\\"OK\\\"\\n\\n db.session.add(document)\\n\\n db.session.commit()\",\n \"def test_update_list(self):\\n u = stellr.UpdateCommand(TEST_HTTP)\\n docs = [{'a': 1}, {'b': 2}]\\n u.add_documents(docs)\\n self.assertEqual(2, len(u._commands))\\n self.assertEqual(u.body,\\n ('{\\\"add\\\": {\\\"doc\\\": {\\\"a\\\": 1}}'\\n ',\\\"add\\\": {\\\"doc\\\": {\\\"b\\\": 2}}}'))\",\n \"def add_documents(self, documents):\\n\\t\\t\\n\\t\\t# flag for StopIteration exceptions\\n\\t\\tmore_documents = True\\n\\t\\t# loop while there are still documents in the iterator\\n\\t\\twhile more_documents:\\n\\t\\t\\t# increment batch number\\n\\t\\t\\tbatch = len(self.batch_stats) + 1\\n\\t\\t\\t# count sentences\\n\\t\\t\\tsentences_count = 0\\n\\t\\t\\t# create temporary batch data file in the version directory\\n\\t\\t\\tbatch_file = os.path.join(self.file_base.get_version_path(self.version), \\\"data.jl.gz.temp\\\")\\n\\t\\t\\t# try to read the next batch of files, catch exception and stop if there are no more\\n\\t\\t\\ttry:\\n\\t\\t\\t\\t# get next document before opening the file just to make sure it's there\\n\\t\\t\\t\\tdocument = documents.next()\\n\\t\\t\\t\\t# open the data file\\n\\t\\t\\t\\twith gzip.open(batch_file, \\\"wb\\\") as outfile:\\n\\t\\t\\t\\t\\t# loop through DOCUMENT_BATCH_SIZE documents\\n\\t\\t\\t\\t\\tfor i in range(DocumentDatabase.DOCUMENT_BATCH_SIZE):\\n\\t\\t\\t\\t\\t\\t# count sentences in document\\n\\t\\t\\t\\t\\t\\tfor paragraph in document[\\\"paragraphs\\\"]:\\n\\t\\t\\t\\t\\t\\t\\tsentences_count += len(paragraph[\\\"sentences\\\"])\\n\\t\\t\\t\\t\\t\\t# write JSON to file one line at a time\\n\\t\\t\\t\\t\\t\\toutfile.write(\\\"%s\\\\n\\\" % json.dumps(document))\\n\\t\\t\\t\\t\\t\\t# if we are not done with this batch, retrieve the next document\\n\\t\\t\\t\\t\\t\\tif i < DocumentDatabase.DOCUMENT_BATCH_SIZE - 1:\\n\\t\\t\\t\\t\\t\\t\\tdocument = documents.next()\\n\\t\\t\\texcept StopIteration:\\n\\t\\t\\t\\t# the end of the documents stream, set the flag to False\\n\\t\\t\\t\\tmore_documents = False\\n\\t\\t\\t# make sure the batch isn't empty\\n\\t\\t\\tif sentences_count > 0:\\n\\t\\t\\t\\t# create the new batch in the file system\\n\\t\\t\\t\\tself.version_batches.create_latest_version()\\n\\t\\t\\t\\t# add the stats to the statistics hash\\n\\t\\t\\t\\tself.batch_stats[batch] = BatchStats(sentences_count)\\n\\t\\t\\t\\t# write the batch statistics to file\\n\\t\\t\\t\\twith codecs.open(self._get_batch_stat_file(batch), \\\"wb\\\", \\\"utf-8\\\") as outfile:\\n\\t\\t\\t\\t\\t# write the JSON representation for the stats\\n\\t\\t\\t\\t\\toutfile.write(json.dumps(self.batch_stats[batch].to_json()))\\n\\t\\t\\t\\t# move the temp data file to the correct location inside the version folder\\n\\t\\t\\t\\tos.rename(batch_file, self._get_batch_file(batch))\",\n \"def get_preprocessed_docs(formatted_docs):\\r\\n preprocessed_docs = {}\\r\\n for idx in formatted_docs.keys():\\r\\n preprocessed_docs[idx] = preprocess(formatted_docs[idx])\\r\\n return preprocessed_docs\",\n \"def load_flattened_documents(data_dir: str, docids: Set[str]) -> Dict[str, List[str]]:\\n unflattened_docs = load_documents(data_dir, docids)\\n flattened_docs = dict()\\n for doc, unflattened in unflattened_docs.items():\\n flattened_docs[doc] = list(chain.from_iterable(unflattened))\\n return flattened_docs\",\n \"def build(self,documents):\\n\\t\\tself.vectorKeywordIndex = self.getVectorKeywordIndex(documents)\\n\\n\\t\\tself.documentVectors = [self.createVector(document) for document in documents]\",\n \"def _build_token_dict(self, corpus: List[List[str]], min_count: int = 3):\\n token2idx = {\\n self.token_pad: 0,\\n self.token_unk: 1,\\n self.token_bos: 2,\\n self.token_eos: 3\\n }\\n\\n token2count = {}\\n for sentence in corpus:\\n for token in sentence:\\n count = token2count.get(token, 0)\\n token2count[token] = count + 1\\n\\n # 按照词频降序排序\\n sorted_token2count = sorted(token2count.items(),\\n key=operator.itemgetter(1),\\n reverse=True)\\n token2count = collections.OrderedDict(sorted_token2count)\\n\\n for token, token_count in token2count.items():\\n if token not in token2idx and token_count >= min_count:\\n token2idx[token] = len(token2idx)\\n\\n self.token2idx = token2idx\\n self.idx2token = dict([(value, key)\\n for key, value in self.token2idx.items()])\\n logging.debug(f\\\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\\\")\\n self.dataset_info['token_count'] = len(self.token2idx)\",\n \"def update_words(data, book_num):\\n\\tglobal word_count\\n\\t#find count of each word in the book and update the dictionary\\n\\tfor words in data:\\n\\t\\tword_count[words][book_num] = (word_count.get(words,0)[book_num] + 1)\\n\\t#print(word_count)\",\n \"def generate_dict(self):\\n dict = defaultdict(list)\\n for i in range(self.no_of_docs-1):\\n doc_txt = self.doc_to_df(i)\\n #assign key to index in dictionary and its locations as tuples(docid,line,wordpos) as the values\\n for j in range(len(doc_txt)):\\n for k in range(doc_txt.shape[1]):\\n key = doc_txt[k][j]\\n dict[key].append((i,j,k))\",\n \"def set(self, doc, fields_values):\\n fields_values = Object.from_bson(fields_values)\\n for k,v in fields_values.items():\\n self._set(doc, k.split('.'), v)\\n impl = self._impl(doc)\\n return impl.update({'_id':doc._id}, {'$set':fields_values})\",\n \"def parse_doc(self, doc_as_list):\\n tweet_id = doc_as_list[0]\\n tweet_date = doc_as_list[1]\\n full_text = doc_as_list[2]\\n url = doc_as_list[3]\\n retweet_text = doc_as_list[4]\\n retweet_url = doc_as_list[5]\\n quote_text = doc_as_list[6]\\n quote_url = doc_as_list[7]\\n term_dict = {}\\n tokenized_text = self.parse_sentence(full_text)\\n doc_length = len(tokenized_text) # after text operations.\\n\\n for i, term in enumerate(tokenized_text):\\n if term not in term_dict.keys():\\n term_dict[term] = [1, [i]]\\n else:\\n term_dict[term][0] += 1\\n term_dict[term][1].append(i)\\n\\n document = Document(tweet_id, tweet_date, full_text, url, retweet_text, retweet_url, quote_text,\\n quote_url, term_dict, doc_length)\\n return document\",\n \"def extract(self, documents):\\n\\n # Feature vector to return\\n features = np.zeros((len(documents), len(self.idx_to_word)))\\n\\n # Raise an exception if 'extract' is called before 'preprocess'\\n if len(self.word_to_idx) == 0 or len(self.idx_to_word) == 0:\\n raise Exception(\\\"Dictionary not initialised.\\\")\\n\\n # Iterate over all documents\\n for idx, doc in enumerate(documents):\\n # Split the doc into a list of words\\n words = extract_words(doc)\\n\\n # For each word\\n for w in words:\\n # Calculate it's frequency, however, keep in mind\\n # that this word may not have been in the training\\n # corpus. In that case, ignore the word.\\n ''' YOUR CODE HERE '''\\n try:\\n features[idx][self.word_to_idx[w]] = words.count(w)\\n except KeyError:\\n pass\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n # Divide the vector by the total number of words in the document to\\n # normalize the frequencies.\\n ''' YOUR CODE HERE '''\\n features[idx] = features[idx]/len(words)\\n ''' END CODE FOR THIS LOOP '''\\n\\n return features\",\n \"def _vector_mapping(self) -> dict:\\n words = set()\\n for file in os.listdir(self.processed_path):\\n doc_path = f\\\"{self.processed_path}/{file}\\\"\\n with open(doc_path, 'r') as f:\\n text_words = f.readline().split()\\n words = words.union(set(text_words))\\n words = list(words)\\n words.sort()\\n\\n return dict(zip(words, range(len(words))))\",\n \"def add(self, token_docid):\\n token = token_docid[0]\\n doc_id = token_docid[1]\\n # collapse identical tokens together\\n if token in self.posting:\\n self.posting[token].append(doc_id)\\n else:\\n self.posting[token] = [doc_id]\",\n \"def __call__(self, doc: Doc) -> Doc:\\n for val in self._get_vals(doc):\\n key = self._get_key(val)\\n try:\\n self._table.get(key).append(val)\\n except AttributeError:\\n self._table.set(key, [val])\\n self._size += 1\\n return super().__call__(doc)\",\n \"def __parse_corpus(self, corpus):\\n corpus = self.__handle_corpus_unkwon_words(corpus)\\n start_token = ' '.join([NGramModel.START_SENTENCE_TOKEN]*(self.__n-1))\\n word_list = corpus.replace(NGramModel.START_SENTENCE_TOKEN, start_token).split()\\n \\n for n in range(1, self.__n+1): \\n self.__ngram_counts[n] = {}\\n for ngram, count in Counter(self.__generate_n_grams(word_list, n)).items():\\n self.__ngram_counts[n][' '.join(ngram)] = count\",\n \"def documents(self, **kw):\\r\\n \\r\\n doc_reader = self.doc_reader\\r\\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))\",\n \"def merge_all_claims_norm_dicts_for_docs(): \\n# docs_norm_scores_dicts_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\"\\n docs_norm_scores_dicts_path = linux_base_path+\\\"/docs_norm_scores_dicts\\\"\\n# all_claims_norms_scores_merged_dict = base_path +\\\"\\\\\\\\all_claims_norms_scores_merged_dict\\\"\\n all_claims_norms_scores_merged_dict = linux_base_path +\\\"/all_claims_norms_scores_merged_dict\\\"\\n for alpha in range(0,11,1):\\n for beta in range(0,10,1):\\n docs_scores_all_claims = {}\\n for filename in os.listdir(docs_norm_scores_dicts_path):\\n (alpha_f,beta_f)=turn_to_float([alpha,beta])\\n if \\\"_alpha_\\\"+str(alpha_f)+\\\"_\\\" in filename and \\\"_beta_\\\"+str(beta_f)+\\\"_\\\" in filename:\\n curr_dict = read_pickle(docs_norm_scores_dicts_path+\\\"/\\\"+filename)\\n docs_scores_all_claims = dict(docs_scores_all_claims.items() + curr_dict.items()) #merge dicts\\n save_pickle(all_claims_norms_scores_merged_dict+\\\"/docs_norm_scores_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f),docs_scores_all_claims)\",\n \"def tokenize_replace_pos(doc_list, language_code, replace_pos,\\n core_num=multiprocessing.cpu_count()):\\n param = [[d, language_code, replace_pos] for d in doc_list]\\n pool = multiprocessing.Pool(core_num)\\n return pool.map(_tokenize_replace_pos4map, param)\",\n \"def refine_tokens( self, tokens ):\\n k = 1.75\\n b = 0.75\\n stop_words_file = \\\"stop_words.txt\\\"\\n all_stopwords = list()\\n refined_tokens_sources = dict()\\n \\n # collect all the stopwords\\n with open( stop_words_file ) as file:\\n lines = file.read()\\n all_stopwords = lines.split( \\\"\\\\n\\\" )\\n \\n for source in tokens:\\n refined_tokens = dict()\\n files = dict()\\n inverted_frequency = dict()\\n file_id = -1\\n total_file_length = 0\\n for item in tokens[ source ]:\\n file_id += 1\\n file_tokens = tokens[ source ][ item ].split(\\\" \\\")\\n if source in \\\"name_desc_edam_help\\\":\\n file_tokens = utils._clean_tokens( file_tokens, all_stopwords )\\n total_file_length += len( file_tokens )\\n term_frequency = dict()\\n for token in file_tokens:\\n if token is not '':\\n file_ids = list()\\n if token not in inverted_frequency:\\n file_ids.append( file_id )\\n else:\\n file_ids = inverted_frequency[ token ]\\n if file_id not in file_ids:\\n file_ids.append( file_id )\\n inverted_frequency[ token ] = file_ids\\n # for term frequency\\n if token not in term_frequency:\\n term_frequency[ token ] = 1\\n else:\\n term_frequency[ token ] += 1\\n files[ item ] = term_frequency\\n N = len( files )\\n average_file_length = float( total_file_length ) / N\\n # find BM25 score for each token of each tool. It helps to determine\\n # how important each word is with respect to the tool and other tools\\n for item in files:\\n file_item = files[ item ]\\n file_length = len( file_item )\\n for token in file_item:\\n tf = file_item[ token ]\\n # normalize the term freq of token for each document\\n tf = float( tf ) / file_length\\n idf = np.log2( N / len( inverted_frequency[ token ] ) )\\n alpha = ( 1 - b ) + ( float( b * file_length ) / average_file_length )\\n tf_star = tf * float( ( k + 1 ) ) / ( k * alpha + tf )\\n tf_idf = tf_star * idf\\n file_item[ token ] = tf_idf\\n # filter tokens based on the BM25 scores and stop words. Not all tokens are important\\n for item in files:\\n file_tokens = files[ item ]\\n tokens_scores = [ ( token, score ) for ( token, score ) in file_tokens.items() ]\\n sorted_tokens = sorted( tokens_scores, key=operator.itemgetter( 1 ), reverse=True )\\n refined_tokens[ item ] = sorted_tokens\\n tokens_file_name = 'tokens_' + source + '.txt'\\n token_file_path = os.path.join( os.path.dirname( self.tools_data_path ) + '/' + tokens_file_name )\\n with open( token_file_path, 'w' ) as file:\\n file.write( json.dumps( refined_tokens ) )\\n file.close()\\n refined_tokens_sources[ source ] = refined_tokens\\n return refined_tokens_sources\",\n \"def build_ngram_index(tokenized_documents, ngrams):\\n dictionary = {}\\n\\n doc_ngrams = {}\\n for doc in tokenized_documents:\\n ngrams_freq = {}\\n\\n measures = nltk.collocations.BigramAssocMeasures()\\n finder = BigramCollocationFinder.from_words(tokenized_documents[doc])\\n freqs = finder.ngram_fd\\n for ngram in freqs:\\n ngrams_freq[ngram] = freqs[ngram]\\n \\n measures = nltk.collocations.TrigramAssocMeasures()\\n finder = TrigramCollocationFinder.from_words(tokenized_documents[doc])\\n freqs = finder.ngram_fd\\n for ngram in freqs:\\n ngrams_freq[ngram] = freqs[ngram]\\n\\n doc_ngrams[doc] = ngrams_freq\\n\\n for ngram in ngrams:\\n dictionary[ngram] = [0]\\n for doc in doc_ngrams:\\n if ngram in doc_ngrams[doc]:\\n dictionary[ngram][0] += doc_ngrams[doc][ngram]\\n dictionary[ngram].append((doc, doc_ngrams[doc][ngram]))\\n \\n return dictionary\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68999934","0.6873283","0.6396484","0.6270356","0.6200283","0.61873966","0.61502284","0.6042249","0.6037067","0.5998114","0.59293014","0.58950543","0.5877849","0.5844076","0.58293545","0.5767847","0.57396615","0.5730059","0.5711739","0.563978","0.5620126","0.5615571","0.56092644","0.5603466","0.56021726","0.5600261","0.5598487","0.55603933","0.5559371","0.55493385","0.5548632","0.55470467","0.5522555","0.55198544","0.55169094","0.55155396","0.5506191","0.55021423","0.54889655","0.5485269","0.5481285","0.54811215","0.546951","0.5465656","0.54644924","0.54629964","0.5460012","0.54479206","0.5440121","0.54227835","0.5421363","0.5409679","0.5388636","0.5374139","0.53666866","0.53637534","0.5349924","0.5345804","0.53425455","0.534189","0.5330862","0.53307176","0.53249925","0.5320999","0.53199095","0.5316637","0.5293466","0.5287339","0.5282561","0.5279928","0.52778906","0.52778906","0.5275979","0.52614784","0.5259829","0.5256893","0.5256046","0.52554494","0.5247021","0.5243727","0.5235125","0.52288884","0.5227093","0.5222334","0.52207357","0.5218011","0.52138984","0.52111065","0.5208889","0.5208375","0.5207914","0.52025336","0.5198126","0.5186816","0.51824564","0.5160686","0.5158809","0.51471984","0.51395386","0.5131306"],"string":"[\n \"0.68999934\",\n \"0.6873283\",\n \"0.6396484\",\n \"0.6270356\",\n \"0.6200283\",\n \"0.61873966\",\n \"0.61502284\",\n \"0.6042249\",\n \"0.6037067\",\n \"0.5998114\",\n \"0.59293014\",\n \"0.58950543\",\n \"0.5877849\",\n \"0.5844076\",\n \"0.58293545\",\n \"0.5767847\",\n \"0.57396615\",\n \"0.5730059\",\n \"0.5711739\",\n \"0.563978\",\n \"0.5620126\",\n \"0.5615571\",\n \"0.56092644\",\n \"0.5603466\",\n \"0.56021726\",\n \"0.5600261\",\n \"0.5598487\",\n \"0.55603933\",\n \"0.5559371\",\n \"0.55493385\",\n \"0.5548632\",\n \"0.55470467\",\n \"0.5522555\",\n \"0.55198544\",\n \"0.55169094\",\n \"0.55155396\",\n \"0.5506191\",\n \"0.55021423\",\n \"0.54889655\",\n \"0.5485269\",\n \"0.5481285\",\n \"0.54811215\",\n \"0.546951\",\n \"0.5465656\",\n \"0.54644924\",\n \"0.54629964\",\n \"0.5460012\",\n \"0.54479206\",\n \"0.5440121\",\n \"0.54227835\",\n \"0.5421363\",\n \"0.5409679\",\n \"0.5388636\",\n \"0.5374139\",\n \"0.53666866\",\n \"0.53637534\",\n \"0.5349924\",\n \"0.5345804\",\n \"0.53425455\",\n \"0.534189\",\n \"0.5330862\",\n \"0.53307176\",\n \"0.53249925\",\n \"0.5320999\",\n \"0.53199095\",\n \"0.5316637\",\n \"0.5293466\",\n \"0.5287339\",\n \"0.5282561\",\n \"0.5279928\",\n \"0.52778906\",\n \"0.52778906\",\n \"0.5275979\",\n \"0.52614784\",\n \"0.5259829\",\n \"0.5256893\",\n \"0.5256046\",\n \"0.52554494\",\n \"0.5247021\",\n \"0.5243727\",\n \"0.5235125\",\n \"0.52288884\",\n \"0.5227093\",\n \"0.5222334\",\n \"0.52207357\",\n \"0.5218011\",\n \"0.52138984\",\n \"0.52111065\",\n \"0.5208889\",\n \"0.5208375\",\n \"0.5207914\",\n \"0.52025336\",\n \"0.5198126\",\n \"0.5186816\",\n \"0.51824564\",\n \"0.5160686\",\n \"0.5158809\",\n \"0.51471984\",\n \"0.51395386\",\n \"0.5131306\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67038983"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":7383,"cells":{"query":{"kind":"string","value":"Update dictionary from a collection of documents. Each document is a list of tokens."},"document":{"kind":"string","value":"def add_document_lists(self, docs):\n for sent in docs:\n sent = map(self.process_token, sent)\n self._token_count.update(sent)"},"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_documents(self, docs):\n for sent in docs:\n sent = map(self.process_token, sent)\n self._token_count.update(sent)","def add_documents(self, docs):\n if 'sentences' in docs:\n for sent in docs.sentences:\n sent = map(self.process_token, [t for t in sent.tokens if not t.is_stopword])\n self._token_count.update(sent)\n\n else:\n sent = list(map(self.process_token, [t for t in docs.tokens if not t.is_stopword]))\n self._token_count.update(sent)","def add_to_dict(self, tokens):\n# TODO: ?add normalization of a token?\n for token in tokens:\n if self.embedding_words and (token not in self.embedding_words):\n continue\n self.freq[token] += 1\n if token not in self.tok2ind:\n index = len(self.tok2ind)\n self.tok2ind[token] = index\n self.ind2tok[index] = token","def update(tokens):\n global TOKENS\n\n for token_id in tokens:\n\n if token_id not in TOKENS:\n TOKENS[token_id] = {}\n\n if isinstance(tokens, dict):\n token_info = tokens[token_id]\n if token_info is None:\n token_info = {}\n\n alias = token_info.get(\"alias\")\n if alias is not None:\n TOKENS[token_id][\"alias\"] = alias\n\n decimals = token_info.get(\"decimals\")\n if decimals is not None:\n TOKENS[token_id][\"decimals\"] = decimals","def intern_documents(documents: Dict[str, List[List[str]]], word_interner: Dict[str, int], unk_token: str):\n ret = dict()\n unk = word_interner[unk_token]\n for docid, sentences in documents.items():\n ret[docid] = [[word_interner.get(w, unk) for w in s] for s in sentences]\n return ret","def update_existing(doc_data_tples):\n def per_doc(doc, data_tples):\n def per_field(data_tple):\n field, datas = data_tple\n map(_do_append_field(doc, field), datas)\n map(per_field, data_tples)\n return doc\n\n __docs = ( (per_doc(doc, data_tples), data_tples) for doc,data_tples in doc_data_tples )\n return __docs","def updateDocumentAll(self, documents):\n docs = []\n for document in documents:\n if isinstance(document, couch.Document):\n document = document.getData()\n\n # these are required params\n if \"_id\" not in document or \"_rev\" not in document:\n raise Exception(\"Both _id & _rev fields are required!\")\n\n docs.append(document)\n\n return self.client.post(self.name +\"/_bulk_docs\", None,\n {\"docs\": docs}).getBodyData()","def update_from_document(self, document_path):\n with open(document_path, 'r') as document_file:\n for sentence in document_file:\n words = sentence.strip().split()\n for word in words:\n self._add_new_word(word)","def preprocess(self, documents):\n\n # A dict storing the frequency of each word\n word_freq = {}\n\n # Iterate for each document\n for doc in documents:\n # Split the document into a list of words and iterate on it\n for w in extract_words(doc):\n # Update word frequencies\n '''YOUR CODE HERE'''\n if w not in word_freq.keys():\n word_freq[w] = 1\n else:\n word_freq[w] += 1\n\n ''' END CODE FOR THIS LOOP '''\n\n\n # A set of words with frequency less than 'self.min_freq'\n remove_words = set()\n\n # Check frequency of each word and add to 'remove_words'\n # if it's frequency is below self.min_freq\n\n ''' YOUR CODE HERE '''\n for w in word_freq.keys():\n if word_freq[w] < self.min_freq:\n remove_words.add(w)\n\n # Delete the words in 'remove_words' from 'word_freq'\n for w in remove_words:\n del word_freq[w]\n\n # Fill 'self.word_to_idx' and 'self.idx_to_word' for\n # each word in 'word_freq' (dicts are explained above)\n\n i = 0\n for w in word_freq.keys():\n self.word_to_idx[w] = i\n self.idx_to_word[i] = w \n i += 1\n\n ''' END YOUR CODE HERE '''","def fit(self, documents):\n # Get a list of all the unique tokens that appear\n vocab = list({\n token for doc in documents\n for token in self.tokenizer(doc)\n if token not in self._word2index\n })\n\n # This is UNK, START, END, and PAD.\n nb_special_tokens = 4\n\n # First, we map token -> ID, leaving the first slots for special tokens\n self._word2index.update({\n word: idx\n for idx, word in enumerate(vocab, nb_special_tokens)\n })\n\n # Next, we invert this map, which we can do since it was built from\n # unique vocabulary elements and is by definition bijective.\n self._index2word.update({\n idx: word\n for word, idx in self._word2index.items()\n })\n\n return self","def multiple_document_processing(self) -> List:\n batch_list = []\n for doc, idx in self.__documents:\n entities_idx = {'idx': idx}\n entities_result = self.create_entity(document=doc)\n word_cleaned = self.clean_words(doc)\n entities_idx[self.key_spacy_text] = str(word_cleaned)\n entities_idx.update(entities_result)\n batch_list.append(entities_idx)\n return batch_list","def get_doc_dicts(self, doc_ids):\n pass","def updateMultipleDocuments(cred, payload):\n\n url = cred.base_url + \"documents:commit\"\n data = { 'writes': [] }\n\n for path, fieldData in payload.iteritems():\n pathData = createFirestoreDataObject(cred, path, fieldData)\n data['writes'].append(pathData)\n \n makeRequest(cred, url, 'POST', data)","def add_doc_in_posting_list(word_posting_list, docs):\n for doc_score in docs:\n if doc_score[\"doc\"] in word_posting_list.keys():\n word_posting_list[doc_score[\"doc\"]] = int(doc_score[\"score\"]) + int(word_posting_list[doc_score[\"doc\"]])\n else:\n word_posting_list[doc_score[\"doc\"]] = doc_score[\"score\"]","def load(self, documents, uniquify=False):\n assert documents, \"missing list of documents, text single doc per line\"\n assert isinstance(documents, list), \"documents must be list\"\n assert isinstance(documents[0], list), \"each document is also a list\"\n #--------------------------------------------------------------------------------------------\n\n def _get_new_counts(document):\n return Counter(document) if not uniquify else Counter(list(set(document)))\n\n for idx, document in enumerate(documents):\n new_counter = _get_new_counts(document)\n self.counter.update(new_counter)\n if idx % 1000 == 0:\n print(\"load: {}\\r\".format(idx), end='')\n return self","def parse_doc(self, doc_as_list):\n\n tweet_id = doc_as_list[0]\n tweet_date = doc_as_list[1]\n full_text = doc_as_list[2]\n url = doc_as_list[3]\n indice = doc_as_list[4]\n retweet_text = doc_as_list[5]\n retweet_url = doc_as_list[6]\n retweet_indice = doc_as_list[7]\n quote_text = doc_as_list[8]\n quote_url = doc_as_list[9]\n quoted_indice = doc_as_list[10]\n retweet_quoted_text = doc_as_list[11]\n retweet_quoted_url = doc_as_list[12]\n retweet_quoted_indice = doc_as_list[13]\n\n term_dict = {}\n\n tokenized_text = self.parse_sentence(full_text)\n tokenized_quote = self.parse_sentence(quote_text)\n # tokenized_url = self.handle_url(url)\n\n\n doc_length = len(tokenized_text) # after text operations - length of full_text\n\n new_tokenized_text = tokenized_text + tokenized_quote\n\n # spell checker\n # new_tokenized_text = self.spell.update(new_tokenized_text)\n\n for term in new_tokenized_text:\n if term is not \"\": # or (term.isalpha() and len(term) == 1)\n if term not in term_dict:\n term_dict[term] = 1\n else:\n term_dict[term] += 1\n\n document = Document(tweet_id, tweet_date, full_text, url, retweet_text, retweet_url, quote_text,\n quote_url, term_dict, doc_length)\n return document","def prepare_dictionary_from_docs(self):\n if os.path.exists(self.DICT_PATH):\n return True\n self.logger.info(\"START PREPARING DICT\")\n for fn in os.listdir(self.wiki_path):\n self.logger.info(\"dict update {0}\".format(fn))\n content = self.get_processed_content(fn)\n self.dictionary.add_documents([content])\n self.dictionary.filter_extremes(no_below=20, no_above=0.1, keep_n=100000)\n self.dictionary.compactify()\n self.dictionary.save(self.DICT_PATH)\n return True","def get_dict(cleaned_docs):\n data = []\n for doc in cleaned_docs:\n data += doc\n return list(set(data))","def transform(self, docs):\n return [doc for doc in docs]","def doc2bow(self, document, allow_update=False, return_missing=False):\n\n doc=[t.text for t in document.tokens]\n\n if isinstance(doc, string_types):\n raise TypeError(\"doc2bow expects an array of unicode tokens on input, not a single string\")\n\n # Construct (word, frequency) mapping.\n counter = defaultdict(int)\n for w in doc:\n counter[w if isinstance(w, str) else str(w, 'utf-8')] += 1\n\n token2id = self.token2id\n if allow_update or return_missing:\n missing = sorted(x for x in iteritems(counter) if x[0] not in token2id)\n if allow_update:\n for w, _ in missing:\n # new id = number of ids made so far;\n # NOTE this assumes there are no gaps in the id sequence!\n token2id[w] = len(token2id)\n result = {token2id[w]: freq for w, freq in iteritems(counter) if w in token2id}\n\n if allow_update:\n self.num_docs += 1\n self.num_pos += sum(itervalues(counter))\n self.num_nnz += len(result)\n # keep track of document and collection frequencies\n for tokenid, freq in iteritems(result):\n self.cfs[tokenid] = self.cfs.get(tokenid, 0) + freq\n self.dfs[tokenid] = self.dfs.get(tokenid, 0) + 1\n\n # return tokenids, in ascending id order\n result = sorted(iteritems(result))\n if return_missing:\n return result, dict(missing)\n else:\n return result","def _build_token_dict(self, corpus: List[List[str]]):\n self.token2idx = self.load_from_vocab_file(self.vocab_path)\n self.idx2token = dict([(value, key)\n for key, value in self.token2idx.items()])\n logging.debug(f\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\")\n self.dataset_info['token_count'] = len(self.token2idx)","def docs2ids(self):\n self.docs = [ [self.vocab[word] for word in doc] for doc in self.docs]","def update_all(cls, documents: List[dict]) -> (List[dict], List[dict]):\n if not documents:\n raise ValidationFailed([], message=\"No data provided.\")\n\n if not isinstance(documents, list):\n raise ValidationFailed(documents, message=\"Must be a list.\")\n\n new_documents = copy.deepcopy(documents)\n\n errors = cls.validate_and_deserialize_update(new_documents)\n if errors:\n raise ValidationFailed(documents, errors)\n\n try:\n if cls.logger.isEnabledFor(logging.DEBUG):\n cls.logger.debug(f\"Updating {new_documents}...\")\n previous_documents, updated_documents = cls._update_many(new_documents)\n if cls.logger.isEnabledFor(logging.DEBUG):\n cls.logger.debug(f\"Documents updated to {updated_documents}.\")\n return (\n [cls.serialize(document) for document in previous_documents],\n [cls.serialize(document) for document in updated_documents],\n )\n except pymongo.errors.DuplicateKeyError:\n raise ValidationFailed(\n [cls.serialize(document) for document in documents],\n message=\"One document already exists.\",\n )","def load_documents(data_dir: str, docids: Set[str] = None) -> Dict[str, List[List[str]]]:\n if os.path.exists(os.path.join(data_dir, 'docs.jsonl')):\n assert not os.path.exists(os.path.join(data_dir, 'docs'))\n return load_documents_from_file(data_dir, docids)\n\n docs_dir = os.path.join(data_dir, 'docs')\n res = dict()\n if docids is None:\n docids = sorted(os.listdir(docs_dir))\n else:\n docids = sorted(set(str(d) for d in docids))\n for d in docids:\n with open(os.path.join(docs_dir, d), 'r') as inf:\n lines = [l.strip() for l in inf.readlines()]\n lines = list(filter(lambda x: bool(len(x)), lines))\n tokenized = [list(filter(lambda x: bool(len(x)), line.strip().split(' '))) for line in lines]\n res[d] = tokenized\n return res","def load_documents_from_file(data_dir: str, docids: Set[str] = None) -> Dict[str, List[List[str]]]:\n docs_file = os.path.join(data_dir, 'docs.jsonl')\n documents = load_jsonl(docs_file)\n documents = {doc['docid']: doc['document'] for doc in documents}\n res = dict()\n if docids is None:\n docids = sorted(list(documents.keys()))\n else:\n docids = sorted(set(str(d) for d in docids))\n for d in docids:\n lines = documents[d].split('\\n')\n tokenized = [line.strip().split(' ') for line in lines]\n res[d] = tokenized\n return res","def initialize_terms_and_postings():\n global dictionary, postings\n for id in document_filenames:\n document = getDocumentContent(document_filenames[id])\n if(document_filenames[id].rfind(\".pdf\") == len(document_filenames[id]) - 4):\n terms = tokenize(document.encode('utf-8'))\n if(document_filenames[id].rfind(\".txt\") == len(document_filenames[id]) - 4):\n terms = tokenize(document)\n if(document_filenames[id].rfind(\".docx\") == len(document_filenames[id]) - 5):\n terms = tokenize(document)\n if(document_filenames[id].rfind(\".pptx\") == len(document_filenames[id]) - 5):\n terms = tokenize(document)\n unique_terms = set(terms)\n dictionary = dictionary.union(unique_terms)\n for term in unique_terms:\n postings[term][id] = terms.count(term) # the value is the\n # frequency of the\n # term in the\n # document","def _create_dictionary(self, document_set):\n words = self._normalize_words(document_set.words)\n unique_words = frozenset(words)\n return dict((word, idx) for idx, word in enumerate(unique_words))","def set_keyword_map(self):\n \n ret = defaultdict(list)\n for idx, doc in enumerate(self.docs):\n for token in doc:\n if token in self.dictionary.token2id:\n ret[token].append(idx)\n \n self.keyword_map = ret\n return ret","def clean_docs(self,docs):\n\n # Remove numbers, but not words that contain numbers.\n docs = [[token for token in doc if not token.isnumeric()] for doc in docs]\n\n # Remove words that are only one character.\n docs = [[token for token in doc if len(token) > 1 and token not in stop_words] for doc in docs]\n\n # lemmatizer = WordNetLemmatizer()\n # docs = [[lemmatizer.lemmatize(token) for token in doc] for doc in docs]\n\n # Add bigrams and trigrams to docs (only ones that appear 20 times or more).\n bigram = Phrases(docs, min_count=20)\n for idx in range(len(docs)):\n for token in bigram[docs[idx]]:\n if '_' in token:\n # Token is a bigram, add to document.\n docs[idx].append(token)\n\n # Create a dictionary representation of the documents.\n dictionary = Dictionary(docs)\n\n # Filter out words that occur less than 20 documents, or more than 50% of the documents.\n dictionary.filter_extremes(no_below=20, no_above=0.5)\n\n # Bag-of-words representation of the documents.\n corpus = [dictionary.doc2bow(doc) for doc in docs]\n\n return docs,dictionary,corpus","def add_new_doc(self, document, documents_list_length=10000):\n\n try:\n document_dictionary = document.term_doc_dictionary\n # self.countDoc += 1\n for term in document_dictionary.keys():\n if self.stemming == 'y':\n my_stemmer = Stemmer()\n term = my_stemmer.stem_term(term)\n # Update inverted index and posting\n if term not in self.inverted_idx.keys():\n self.inverted_idx[term] = [1, [\n (document_dictionary[term], document.tweet_id)]] # amount of doc, freq in the doc, doc id.\n\n else:\n self.inverted_idx[term][0] += 1 # amount of doc\n self.inverted_idx[term][1].append((document_dictionary[term],\n document.tweet_id)) # freq in the doc # doc id\n\n if term not in self.postingDict.keys():\n self.postingDict[term] = [(document.tweet_id, document_dictionary[term])]\n else:\n self.postingDict[term].append((document.tweet_id, document_dictionary[term]))\n # self.countTweet -= 1\n\n if document.tweet_id not in self.tweet_dict.keys():\n self.tweet_dict[document.tweet_id] = [[term, document_dictionary[term]], 1,\n 0] # [term,freq in tweet], amount of unique terms in tweet, amount of terms in tweet\n elif document_dictionary[term] > self.tweet_dict[document.tweet_id][0][\n 1]: # tweet exist, compering between freq in two terms\n if self.tweet_dict[document.tweet_id][0][\n 1] == 1: # before change term check if the last term is unique\n self.tweet_dict[document.tweet_id][\n 1] += 1 # last term is unique: add to the amount of uniqe terms in tweet\n self.tweet_dict[document.tweet_id][0] = [term,\n document_dictionary[term]] # change between the terms\n self.tweet_dict[document.tweet_id][2] += 1\n elif document_dictionary[term] == 1: # tweet exist, not most common, check if unique\n self.tweet_dict[document.tweet_id][1] += 1\n self.tweet_dict[document.tweet_id][2] += 1\n except:\n # print('problem in indexer : add_new_doc')\n # print(traceback.print_exc())\n pass","def add(self, document):\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\n if not token.isalpha():\n continue\n\n if token in self.stopwords:\n continue\n \n if self.stemmer:\n token = self.stemmer.stem(token)\n \n if self.__unique_id not in self.index[token]:\n self.index[token].append(self.__unique_id)\n \n self.documents[self.__unique_id] = document\n self.__unique_id += 1","def preprocess(self, documents):\n\n # Store the total number of documents\n num_docs = np.float(len(documents))\n\n # A dict storing the frequency of each word across all documents\n total_word_freq = {}\n\n # A dict storing the number of documents that word appears in\n doc_word_freq = {}\n\n # Iterate over all documents\n for doc in documents:\n # Split the string into a list of words\n words = extract_words(doc)\n\n # Update the 'total_word_freq' dict using all words in 'words'\n for w in words:\n ''' YOUR CODE HERE '''\n if w not in total_word_freq.keys():\n total_word_freq[w] = 1\n else:\n total_word_freq[w] += 1\n\n ''' END CODE FOR THIS LOOP '''\n\n # Update the 'doc_word_freq' dict. Remember to only add '1' corresponding to\n # each word in a document. In case a word appears twice in a document, then\n # it should be ignored. We use the set() data structure to achieve this.\n for w in set(words):\n ''' YOUR CODE HERE '''\n if w not in doc_word_freq:\n doc_word_freq[w] = 1\n else:\n doc_word_freq[w] += 1\n\n ''' END CODE FOR THIS LOOP '''\n\n # A set of words with total frequency less than 'self.min_freq'\n remove_words = set()\n\n ''' YOUR CODE HERE '''\n\n # Check frequency of each word and add to 'remove_words'\n for w in total_word_freq.keys():\n if total_word_freq[w] < self.min_freq:\n remove_words.add(w)\n\n # Delete the words in 'remove_words' from 'total_word_freq' and\n # 'doc_word_freq'.\n for w in remove_words:\n del total_word_freq[w]\n del doc_word_freq[w]\n\n # Create a numpy array to store frequencies from which\n # we can create the 'self.idf' preprocessed numpy array.\n word_freq_tensor = np.zeros(len(doc_word_freq))\n\n # For each word in 'doc_word_freq' dict, update\n # 'self.word_to_idx' and 'self.idx_to_word' and\n # 'word_freq_tensor'.\n i = 0\n for w in doc_word_freq.keys():\n self.word_to_idx[w] = i \n self.idx_to_word[i] = w\n word_freq_tensor[i] = doc_word_freq[w]\n i+=1\n \n #print(word_freq_tensor.shape)\n #print(word_freq_tensor)\n # Calculate 'self.idf' (see hint.pdf for formula)\n self.idf = -1*np.log(word_freq_tensor/(len(documents)))\n ''' END YOUR CODE HERE '''","def process_new_tokens(tokens,processed_tokens_set, model, dictionary):\n if hasattr(model, 'using_pretrained') and model.using_pretrained is not None:\n processed_tokens_set.update(tokens)\n update_embedding_layer(processed_tokens_set, model, dictionary)","def process_document(text):\n words = preprocess(text)\n postings = {}\n for word, ix in words:\n if word in postings:\n wordinfo = postings[word]\n else:\n wordinfo = {\"frequency\": 0, \"indexes\": []}\n postings[word] = wordinfo\n wordinfo[\"frequency\"] += 1\n wordinfo[\"indexes\"].append(ix)\n return postings","def pre_process(self, documents):\n\n return documents","def insert_many(self, documents: Iterable[dict]) -> None:\n for i, document in enumerate(documents):\n if isinstance(document, dict):\n self._store_document(document)\n else:\n raise TypeError(\n f\"The document at index {i} was not a dictionary. All documents must be dictionaries.\"\n )\n self._dump()","def _docMapping(self):\n doc2quests = defaultdict(list)\n for q, d in self.quest2doc.items():\n doc2quests[d].append(q)\n return doc2quests","def create_document_dictionary(documents):\n \n document_dictionary = dict()\n for document in documents:\n document_dictionary[document.cord_uid] = document\n return document_dictionary","def transform4Doc2Vec(docs):\n\n # transform documents to be used by doc2Vec\n documents = []\n analyzedDocument = namedtuple('AnalyzedDocument', 'words tags')\n for i, doc in enumerate(docs):\n # use first line if documents are not tokenized, otherwise next line\n # words = text.lower().split()\n tags = [i]\n documents.append(analyzedDocument(doc, tags))\n\n return documents","def _create_dictionary(self, document):\n words = self._normalize_words(document.words)\n unique_words = frozenset(words)\n return dict((word, idx) for idx, word in enumerate(unique_words))","def enrich(self, lazy_corpus_loader, fileids=None):\n tag_dict = self.tag_dict\n word_tag_dict = self.word_tag_dict\n for word_tag in lazy_corpus_loader.tagged_words(fileids=fileids):\n word = word_tag[0]\n tag = word_tag[1]\n if not tag_dict.get(tag, None):\n raise KeyError, \"Unknown pos-tag: %s\" % tag\n tag_dict = word_tag_dict.get(word, {})\n tag_dict[tag] = tag_dict.get(tag, 0) + 1\n word_tag_dict[word] = tag_dict\n self.word_tag_dict = word_tag_dict","def add(self, tokens):\n\n for token in tokens:\n self.vocab.add(token)\n\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\n if leader not in self.frequencies:\n self.frequencies[leader] = Frequency()\n\n self.frequencies[leader].add(token)","def set_doc_phrases(doc_phrases, docs, phrases):\n for doc in docs:\n if not doc in doc_phrases:\n doc_phrases[doc] = []\n doc_phrases[doc] = doc_phrases[doc] + phrases","def tokenize_document(doc_info: dict, tokenizer: BertTokenizer, max_doc_length: int = None) -> dict:\n sub_tokens: List[str] = [] # all sub tokens of a document\n sentence_map: List[int] = [] # collected tokenized tokens -> sentence id\n subtoken_map: List[int] = [] # collected tokenized tokens -> original token id\n\n word_idx = -1\n\n for sentence_id, sentence in enumerate(doc_info['sentences']):\n for token in sentence:\n word_idx += 1\n word_tokens = tokenizer.tokenize(token)\n sub_tokens.extend(word_tokens)\n sentence_map.extend([sentence_id] * len(word_tokens))\n subtoken_map.extend([word_idx] * len(word_tokens))\n if max_doc_length:\n num_to_pad = max_doc_length - len(sub_tokens)\n sub_tokens.extend([\"[PAD]\"] * num_to_pad)\n sentence_map.extend([sentence_map[-1]+1] * num_to_pad)\n subtoken_map.extend(list(range(word_idx+1, num_to_pad+1+word_idx)))\n # global MAX_LENGTH\n # if len(sub_tokens) > MAX_LENGTH:\n # print(len(sub_tokens))\n # MAX_LENGTH = len(sub_tokens)\n # print(MAX_LENGTH)\n # todo(yuxian): need pad speakers?\n speakers = {subtoken_map.index(word_index): tokenizer.tokenize(speaker)\n for word_index, speaker in doc_info['speakers']}\n clusters = [[(subtoken_map.index(start), len(subtoken_map) - 1 - subtoken_map[::-1].index(end))\n for start, end in cluster] for cluster in doc_info['clusters']]\n tokenized_document = {'sub_tokens': sub_tokens, 'sentence_map': sentence_map, 'subtoken_map': subtoken_map,\n 'speakers': speakers, 'clusters': clusters, 'doc_key': doc_info['doc_key']}\n return tokenized_document","def replace_words_fun(self):\n\n cleaned_doc = []\n for word in str(self.doc).split():\n if word.lower() in self.replacement_list.keys():\n cleaned_doc.append(self.replacement_list[word.lower()])\n else:\n cleaned_doc.append(word)\n self.doc = ' '.join(cleaned_doc)","def get_idf_dict(clean_corpus, tf_list, num_docs):\n \n idf_dict = {}\n for i in range(num_docs):\n for key in tf_list[i].keys():\n if key not in idf_dict.keys():\n idf_dict[key] = 0\n idf_dict[key] = idf_dict[key] + 1\n \n for key in idf_dict.keys():\n idf_dict[key] = math.log2(num_docs/idf_dict[key])\n # idf_dict's keys -> all unique tokens in the corpus \n return idf_dict","def initialize_document_frequencies():\n global document_frequency\n for term in dictionary:\n document_frequency[term] = len(postings[term])","def preprocess_corpus(corpus, stop_list, stop_words=True, stemm=True, bag_words=True):\n corpus_preprocessed = list()\n for element in corpus:\n new_element = dict()\n new_element['document'] = preprocess_document(element['text'], stop_list, stop_words, stemm, bag_words)\n new_element['id'] = element['id']\n corpus_preprocessed.append(new_element)\n\n return corpus_preprocessed","def create_tokens_li():\n cnt=0\n for file in docs:\n file_name = open(\"./corpus/\"+ str(file) + \".txt\")\n print(cnt)\n cnt+=1\n words = file_name.read()\n tokens_doc = nltk.word_tokenize(words)\n tokens_doc = [w.lower() for w in tokens_doc]\n #tokens_doc = [snowball_stemmer.stem(token) for token in tokens_doc]\n tokens_doc = [token for token in tokens_doc if token not in nltk.corpus.stopwords.words('english')]\n tokens_li.append(tokens_doc)\n\n\n #storing in json file\n with open('savers/tokens.json', 'w') as fp:\n json.dump(tokens_li, fp)","def documents(self, documents):\n\n self._documents = documents","def documents_to_dict(documents: List[Dict]) -> Dict[str, Dict]:\n res = {}\n for doc in documents:\n res[doc['id']] = doc\n return res","def map_docs(docs_file):\n word_map = defaultdict(int)\n doc_count = 0\n token_count = 0\n\n for _, doc_tokens in tokenize(docs_file):\n doc_count += 1 # count document\n token_count += len(doc_tokens) # count tokens\n for token in set(doc_tokens):\n word_map[token] += 1 # increase inverted index count\n\n docs_file.seek(0) # reset file pointer\n return doc_count, token_count, word_map","def updateScores(rankedLists):\n docToRank = {}\n for rankedList in rankedLists:\n\n f = open(rankedList, 'r')\n for line in f:\n documentID = line.split()[2]\n docno = documentID\n score = float(line.split()[4])\n position = int(line.split()[3])\n docToRank[docno] = (position,score)\n f.close()\n client = MongoClient('asr2.iem.technion.ac.il',27017)\n db = client.asr16\n documents = db.documents.find({})\n for document in documents:\n key = document[\"query_id\"]+\"-\"+document[\"username\"]\n document['position'] = docToRank[key][0]\n document['score'] = docToRank[key][1]\n document['posted_document'] = document['current_document']\n db.documents.save(document)","def merge_docs(self):","def run(self, mapping={}, *args, **kwargs):\n self.processed = 0\n for batch in self._process_by_batch(self.load(*args, **kwargs)):\n batch = list(map(lambda doc: self._apply_mapping(doc, mapping), batch))\n for doc in batch:\n self._ingest(iterable=doc, doctype=doc[\"doctype\"])\n self.processed += 1\n logger.info(\"Added {} documents to the database.\".format(self.processed))","def make_vocab_from_docs(docs):\n vocab_words=set()\n for doc in docs:\n doc=doc.lower()\n doc=re.sub(r'-',' ',doc)\n doc=re.sub(r' +',' ',doc) # turn multiple spaces into a single space\n doc=re.sub(r'[^a-z ]','',doc) # remove anything that is not a-z or space\n words=set(doc.split())\n vocab_words=vocab_words.union(words)\n vocab=dict(zip(vocab_words,range(len(vocab_words))))\n return vocab","def _prepare_analysis_input(self, documents):\n subdoc_to_doc_map = {}\n wordtype_to_number = {}\n number_to_wordtype = []\n wordtypes = {}\n \n # prevent duplicating work\n if os.path.exists(self.wordtype_file):\n return\n \n try:\n # First find singletons\n if self.remove_singletons:\n word_type_count_threshold = max(1, int(math.log(documents.count(), 10)) - 2)\n temp_word_type_counts = {}\n for doc_index, doc in enumerate(documents):\n tokens = self.tokenize(doc.get_content())\n for token, token_start in tokens:\n temp_word_type_counts[token] = temp_word_type_counts.setdefault(token, 0) + 1\n for word_type, count in temp_word_type_counts.iteritems(): # add singletons to stopword list\n if count <= word_type_count_threshold:\n self._excluded_words[word_type] = True\n with io.open(self.excluded_words_file, 'w', encoding='utf-8') as ex_f:\n ex_f.write(unicode(json.dumps(self._excluded_words)))\n \n haltwords = dict(self.stopwords)\n haltwords.update(self._excluded_words)\n # Second find bigrams, iterate through documents and train.\n if self.find_bigrams:\n from import_tool.analysis.bigram_finder import BigramFinder\n bigram_finder = BigramFinder(stopwords=haltwords)\n for doc_index, doc in enumerate(documents):\n bigram_finder.train(doc_index, self.tokenize(doc.get_content()))\n bigram_finder.print()\n \n # Third, we're going to stem words\n if self.stem_words:\n from import_tool.analysis.stemmer import Stemmer\n stemmer = Stemmer(self._working_dir, self.base_dir)\n \n # for each document tokenize and map tokens to numbers to avoid regex problems before passing data to Mallet\n with io.open(self.mallet_input_file, 'w', encoding='utf-8') as w:\n with io.open(self.start_index_file, 'w', encoding='utf-8') as w2:\n count = 0\n subcount = 0\n for doc_index, doc in enumerate(documents):\n doc_content = unicode(doc.get_content())\n count += 1\n subdocuments = self.create_subdocuments(doc_index, doc_content)\n token_start_index_offset = 0 # needed to make sure the start index remains correct once the document is re-merged\n for subdoc_name, subdoc_content in subdocuments:\n if subcount > 0:\n w2.write(u'\\n')\n subcount += 1\n subdoc_to_doc_map[subdoc_name] = doc_index\n tokens = self.tokenize(subdoc_content)\n \n if self.find_bigrams:\n tokens = bigram_finder.combine(tokens, subdoc_content)\n \n token_numbers = []\n token_start_indices = []\n only_tokens = []\n tokens_temp = []\n for tok, tok_start in tokens:\n only_tokens.append(tok)\n tokens_temp.append([tok, tok_start + token_start_index_offset])\n tokens = tokens_temp\n tokens_temp = None\n if self.stem_words:\n stemmed_tokens = stemmer.stem(only_tokens)\n else:\n stemmed_tokens = only_tokens\n for tup, tok_stem in zip(tokens, stemmed_tokens):\n tok, tok_start = tup\n wordtypes[tok] = True\n wordtypes[tok_stem] = True\n try:\n tok_num = wordtype_to_number[tok_stem]\n except:\n tok_num = len(wordtype_to_number)\n number_to_wordtype.append(tok_stem)\n wordtype_to_number[tok_stem] = tok_num\n token_numbers.append(unicode(tok_num))\n token_start_indices.append([tok, tok_start])\n text = u' '.join(token_numbers)\n w.write(u'{0} all {1}\\n'.format(subdoc_name, text))\n w2.write(unicode(json.dumps(token_start_indices)))\n token_start_index_offset += len(subdoc_content)\n for tok, tok_start in tokens:\n try:\n assert doc_content[tok_start:tok_start+len(tok)].lower() == tok.lower()\n except:\n print(tok_start)\n print(len(tok))\n print('\"'+doc_content[tok_start:tok_start+len(tok)].lower()+'\"')\n print('\"'+tok.lower()+'\"')\n raise\n if not count:\n raise Exception('No files processed.')\n # record which subdocuments belong to which documents\n with io.open(self.subdoc_to_doc_map_file, 'w', encoding='utf-8') as w:\n w.write(unicode(json.dumps(subdoc_to_doc_map)))\n with io.open(self.wordtype_to_number_file, 'w', encoding='utf-8') as w:\n w.write(unicode(json.dumps(wordtype_to_number)))\n with io.open(self.number_to_wordtype_file, 'w', encoding='utf-8') as w:\n w.write(unicode(json.dumps(number_to_wordtype)))\n with io.open(self.wordtype_file, 'w', encoding='utf-8') as w:\n w.write(unicode(json.dumps(wordtypes)))\n except: # cleanup\n self._cleanup(self.mallet_input_file)\n self._cleanup(self.subdoc_to_doc_map_file)\n self._cleanup(self.wordtype_to_number_file)\n self._cleanup(self.number_to_wordtype_file)\n self._cleanup(self.wordtype_file)\n self._cleanup(self.excluded_words_file)\n raise","def current_word_PL(current_word, file_reader_last_read_list, doc_dict, nb_doc):\n word_posting_list = {} # { key = doc , value = score }\n for idx, file_reader_last_read in enumerate(file_reader_last_read_list):\n if file_reader_last_read[\"last_read\"][\"word\"] == current_word:\n docs = file_reader_last_read[\"last_read\"][\"doc_score_list\"]\n add_doc_in_posting_list(word_posting_list=word_posting_list, docs=docs)\n file_reader_last_read_list[idx]=read_line_and_update(file_reader_and_last_read=file_reader_last_read)\n for key, value in word_posting_list.items():\n tf = float(value) / doc_dict[int(key)]\n idf = math.log((float(nb_doc)/len(word_posting_list)),2)\n score = tf*idf\n word_posting_list[key]=score \n word_posting_list = sort_and_cast_doc_in_posting_list(word_posting_list=word_posting_list)\n return word_posting_list","async def put_documents(self, collection, documents):\n await self.ensure_collection(collection)\n try:\n if SOLR_COMMIT_WITHIN:\n params = {'commitWithin': SOLR_COMMIT_WITHIN}\n else:\n params = {'commit': 'true'}\n await self.post(\n '/v2/collections/{}/update'.format(collection),\n params=params, json_data=documents\n )\n logger.info('Successfully indexed {} documents to collection {}'\n .format(len(documents), collection))\n except SolrError:\n logger.warning('Failed to put {} documents to collection {}'\n .format(len(documents), collection))\n raise","def from_documents(cls, documents):\n # return cls.from_words(_itertools.chain(*documents))\n return cls.from_words(\n cls._build_new_documents(documents, cls.default_ws, pad_right=True)\n )","def add_new_doc(self, document, end_of_corpus):\n max_tf = 0\n unique_terms_counter = 0\n document_dictionary = document.term_doc_dictionary\n # Go over each term in the doc\n for term in document_dictionary:\n try:\n # Update inverted index and posting\n if term not in self.inverted_idx:\n self.inverted_idx[term] = 1\n unique_terms_counter += 1\n else:\n self.inverted_idx[term] += 1\n if term not in self.posting_dict:\n self.posting_dict[term] = []\n\n self.posting_dict[term].append(\n (document.tweet_id, document_dictionary[term])) # key: str , value: array of tuples\n\n max_tf = max(document_dictionary[term], max_tf)\n\n except:\n\n print('problem with the following key {}'.format(term[0]))\n\n document.max_tf = max_tf\n document.unique_terms = unique_terms_counter\n self.docs_count += 1\n\n modulo = int(document.tweet_id) % 10\n self.documents[modulo][document.tweet_id] = [document.term_doc_dictionary, document.max_tf]\n\n if self.docs_count == self.DOCS_SIZE or end_of_corpus: # if we reach chunk size or end of corpus\n self.add_to_file(end_of_corpus)\n self.docs_count = 0\n self.posting_dict = {}\n\n for i in self.documents: # 0 - 9\n if self.documents[i].__len__() > 15000:\n doc = utils.load_obj(self.out + \"document\" + str(i))\n doc.update(self.documents[i])\n utils.save_obj(doc, self.out + \"document\" + str(i))\n self.documents[i] = {}","def upload(self, documents: List[Document], vectorise_func) -> None:\n\n # Add doc_store to documents\n for d in documents:\n d.doc_store = self\n # Check ID uniqueness\n check_duplicate_documents(documents)\n # Check type consistency\n check_document_types(documents)\n # Batching\n batches = batch_items(documents)\n\n # Update document class conveniently\n if issubclass(type(documents[0]), ChunkedDocument):\n self._doc_class = ChunkedDocument\n\n for batch in batches:\n vectorise_func(batch, self)\n self.documents += batch","def add_doc(self, document):\n # Split document up into list of strings\n #words = self.tokenize(document)\n words = document\n # Count word frequencies in this document\n word_counts = {}\n for word in words:\n word_counts[word] = word_counts.get(word, 0) + 1\n # Add word counts as new row to sparse matrix\n self.sparse.append(word_counts)\n # Add to total document count for each word\n for word in word_counts:\n self.doc_count[word] = self.doc_count.get(word, 0) + 1","def _apply_mapping(self, document, mapping):\n if not mapping:\n return document\n new_document = {v: document[k] for k, v in mapping.items() if k in document}\n # Keep track of missing keys\n self.missing_keys.update([k for k in mapping if k not in document])\n\n # Document errors for missing documents\n if not new_document:\n self.failed += 1\n self.failed_ids.append(\n document.get(\"id\", document.get(\"ID\", document.get(\"_id\", None)))\n )\n return new_document","def _merge_conllu_subtokens(self, lines: List[str], doc: Doc)-> Doc:\n # identify and process all subtoken spans to prepare attrs for merging\n subtok_spans = []\n for line in lines:\n parts = line.split(\"\\t\")\n id_, word, lemma, pos, tag, morph, head, dep, _1, misc = parts\n if \"-\" in id_:\n subtok_start, subtok_end = id_.split(\"-\")\n subtok_span = doc[int(subtok_start) - 1 : int(subtok_end)]\n subtok_spans.append(subtok_span)\n # create merged tag, morph, and lemma values\n tags = []\n morphs = {}\n lemmas = []\n for token in subtok_span:\n tags.append(token.tag_)\n lemmas.append(token.lemma_)\n if token._.merged_morph:\n for feature in token._.merged_morph.split(\"|\"):\n field, values = feature.split(\"=\", 1)\n if field not in morphs:\n morphs[field] = set()\n for value in values.split(\",\"):\n morphs[field].add(value)\n # create merged features for each morph field\n for field, values in morphs.items():\n morphs[field] = field + \"=\" + \",\".join(sorted(values))\n # set the same attrs on all subtok tokens so that whatever head the\n # retokenizer chooses, the final attrs are available on that token\n for token in subtok_span:\n token._.merged_orth = token.orth_\n token._.merged_lemma = \" \".join(lemmas)\n token.tag_ = \"_\".join(tags)\n token._.merged_morph = \"|\".join(sorted(morphs.values()))\n token._.merged_spaceafter = (\n True if subtok_span[-1].whitespace_ else False\n )\n\n with doc.retokenize() as retokenizer:\n for span in subtok_spans:\n retokenizer.merge(span)\n\n return doc","def count_doc_frequencies(self, docs):\n frequencyIndex = {}\n doc_id = 0\n for doc in docs:\n for term in doc:\n if term not in frequencyIndex:\n frequencyIndex[term] = [doc_id]\n else:\n for id in frequencyIndex[term]:\n if doc_id == id:\n break\n else:\n frequencyIndex[term].append(doc_id)\n doc_id+=1\n\n for term in frequencyIndex:\n occurences = len(frequencyIndex[term])\n frequencyIndex[term] = occurences\n\n return frequencyIndex","def set_documents(cls, input_list_text: List[str]) -> None:\n cls.documents = input_list_text","def featurize(movies):\n ###TODO \n movies['features'] = \"\" \n get_h = set() \n vocab_dict = {}\n df_dict_return = {}\n tup_list = []\n index_dict = {}\n index_dict_1 = {}\n movie_len = len(movies) \n #print(\"MovieLength::\",movie_len)\n #print(\"MOVIES:::\",movies)\n \n get_h = cal_unique_features(movies) # num_features\n\n vocab_dict = cal_unique_vocab(get_h) # vocab complete\n\n len_vocab = len(get_h)\n \n df_dict_return = cal_unique_docs(get_h,movies) # df(i)\n\n for token in get_h :\n #tup_list.clear()\n #print(\"token_GOTTTTT:::\",token)\n for index,row in movies.iterrows(): \n #print(\"row_got::\",row)\n gen_list = row['tokens']\n #print(\"gen_list::\",gen_list)\n #mov_id = row['movieId'] \n #print(\"mov_id::\",mov_id)\n token_count_1 = Counter(gen_list).most_common()[:1]\n tok = token_count_1[0]\n index_dict_1[index] = tok[1]\n token_count = gen_list.count(token)\n #print(\"token_count::\",token_count)\n tup = (index,token_count)\n #print(\"tuple::\",tup)\n tup_list.append(tup)\n #print(\"LIST_PRINT:::::::::::::\",tup_list)\n index_dict[token] = tup_list\n tup_list = []\n \n \n #print(\"INDEX_DICT:::\",index_dict) # tf(i,d)\n #print(\"INDEX_DICT_1:::\",index_dict_1) # max_k dict per docx\n \n \n for ind, row in movies.iterrows():\n data_list = []\n rows_list = []\n columns_list = []\n gen_list = row['tokens']\n #print(\"TOKENS GOTTT::\",gen_list) \n for gen in gen_list:\n tf = get_tf_value(index_dict,gen,ind)\n #print(\"TF GOTTT::\",tf) \n tf_weight = float( tf / index_dict_1[ind])\n #print(\"tf_weight::\",tf_weight)\n df_weight = float( math.log10( movie_len / df_dict_return[gen] ) )\n #print(\"df_weight::\",df_weight)\n final_tfidf = tf_weight * df_weight\n #print(\"final_tfidf::\",final_tfidf)\n data_list.append(final_tfidf)\n columns_list.append(vocab_dict[gen])\n rows_list.append(0) \n csr = csr_matrix((data_list, (rows_list,columns_list)), shape=(1,len_vocab))\n #print(\"TYPE of CSR GOTT::\",type(csr))\n #print(\"CSR GOTT:::\",csr) \n movies.set_value(ind, 'features', csr)\n \n #print(\"UPDATE movies::\",movies) \n\n return(movies,vocab_dict)\n \n\n pass","def index_terms(self):\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\n self.doc_store.dict.iteritems()]","def updateWordCounts():\n emaildata = loadEmailData()\n englishwords = importDictionary()\n countAllWords(emaildata, englishwords)","def set_document_numbers(notices):\n\n if len(notices) > 1:\n for notice in notices:\n notice['document_number'] = split_doc_num(\n notice['document_number'], notice['effective_on'])\n return notices","def set_document_numbers(notices):\n\n if len(notices) > 1:\n for notice in notices:\n notice['document_number'] = split_doc_num(\n notice['document_number'], notice['effective_on'])\n return notices","def update(self, docs: DocumentArray, *args, **kwargs):\n cursor = self.connection.cursor()\n psycopg2.extras.execute_batch(\n cursor,\n f'UPDATE {self.table} SET DOC = %s WHERE ID = %s',\n [\n (\n doc.SerializeToString(),\n doc.id,\n )\n for doc in docs\n ],\n )\n self.connection.commit()","def add_documents(self, docs):\n for doc in docs:\n assert isinstance(doc, pylastica.document.Document), \"All items in list docs must be of type Document: %r\" % doc\n doc.doc_type = self.name\n return self.index.add_documents(docs)","def updateWordList(emailids):\n with open('res/dictionary.txt', 'r') as f:\n lines = f.readlines()\n words = set([line.strip() for line in lines])\n\n with open('res/dictionary.txt', 'a') as f:\n for emailid in emailids: \n email = e.Email(emailid)\n subject = set(email.parsedsubject)\n body = set(email.body)\n try:\n emailcontent = body.union(subject)\n for word in emailcontent:\n if not word in words:\n words.add(word)\n f.write(word + '\\n')\n except AttributeError:\n print(body)","def update_documents(self, engine_name, documents):\n endpoint = \"engines/{}/documents\".format(engine_name)\n data = json.dumps(documents)\n\n return self.swiftype_session.request('patch', endpoint, data=data)","def create_freq_dict(corpus, doc_info):\n for idx, content in enumerate(corpus):\n word_freq_table = {}\n splitted_sentence = content.split()\n for word in splitted_sentence:\n word = word.lower()\n if word not in word_freq_table:\n word_freq_table[word] = 1\n else:\n word_freq_table[word] += 1\n doc_info[idx]['freq_dict'] = word_freq_table","def index_feats_dict(self):\n doc_features_dict = {}\n\n for index, doc in zip(self.index, self.series):\n # Sets for a doc and feature words\n doc_set = set(doc.split())\n feat_set = set(self.features)\n\n # Shared words between the two sets\n interset_words = doc_set.intersection(feat_set)\n\n # Append to doc_features_dict\n doc_features_dict[index] = list(interset_words)\n\n return doc_features_dict","def pos():\n pos_list = []\n for token in doc:\n pos_list.append(token.pos_)\n setList = list(set(pos_list))\n my_dict = {i: pos_list.count(i) for i in setList}\n print(my_dict)","def finish_documents():\n\n doc_ids = json.loads(request.form['doc_ids'])\n\n for docid in doc_ids:\n\n document = Document.query.filter_by(id=docid).first_or_404()\n\n document.status = \"OK\"\n\n db.session.add(document)\n\n db.session.commit()","def test_update_list(self):\n u = stellr.UpdateCommand(TEST_HTTP)\n docs = [{'a': 1}, {'b': 2}]\n u.add_documents(docs)\n self.assertEqual(2, len(u._commands))\n self.assertEqual(u.body,\n ('{\"add\": {\"doc\": {\"a\": 1}}'\n ',\"add\": {\"doc\": {\"b\": 2}}}'))","def add_documents(self, documents):\n\t\t\n\t\t# flag for StopIteration exceptions\n\t\tmore_documents = True\n\t\t# loop while there are still documents in the iterator\n\t\twhile more_documents:\n\t\t\t# increment batch number\n\t\t\tbatch = len(self.batch_stats) + 1\n\t\t\t# count sentences\n\t\t\tsentences_count = 0\n\t\t\t# create temporary batch data file in the version directory\n\t\t\tbatch_file = os.path.join(self.file_base.get_version_path(self.version), \"data.jl.gz.temp\")\n\t\t\t# try to read the next batch of files, catch exception and stop if there are no more\n\t\t\ttry:\n\t\t\t\t# get next document before opening the file just to make sure it's there\n\t\t\t\tdocument = documents.next()\n\t\t\t\t# open the data file\n\t\t\t\twith gzip.open(batch_file, \"wb\") as outfile:\n\t\t\t\t\t# loop through DOCUMENT_BATCH_SIZE documents\n\t\t\t\t\tfor i in range(DocumentDatabase.DOCUMENT_BATCH_SIZE):\n\t\t\t\t\t\t# count sentences in document\n\t\t\t\t\t\tfor paragraph in document[\"paragraphs\"]:\n\t\t\t\t\t\t\tsentences_count += len(paragraph[\"sentences\"])\n\t\t\t\t\t\t# write JSON to file one line at a time\n\t\t\t\t\t\toutfile.write(\"%s\\n\" % json.dumps(document))\n\t\t\t\t\t\t# if we are not done with this batch, retrieve the next document\n\t\t\t\t\t\tif i < DocumentDatabase.DOCUMENT_BATCH_SIZE - 1:\n\t\t\t\t\t\t\tdocument = documents.next()\n\t\t\texcept StopIteration:\n\t\t\t\t# the end of the documents stream, set the flag to False\n\t\t\t\tmore_documents = False\n\t\t\t# make sure the batch isn't empty\n\t\t\tif sentences_count > 0:\n\t\t\t\t# create the new batch in the file system\n\t\t\t\tself.version_batches.create_latest_version()\n\t\t\t\t# add the stats to the statistics hash\n\t\t\t\tself.batch_stats[batch] = BatchStats(sentences_count)\n\t\t\t\t# write the batch statistics to file\n\t\t\t\twith codecs.open(self._get_batch_stat_file(batch), \"wb\", \"utf-8\") as outfile:\n\t\t\t\t\t# write the JSON representation for the stats\n\t\t\t\t\toutfile.write(json.dumps(self.batch_stats[batch].to_json()))\n\t\t\t\t# move the temp data file to the correct location inside the version folder\n\t\t\t\tos.rename(batch_file, self._get_batch_file(batch))","def get_preprocessed_docs(formatted_docs):\r\n preprocessed_docs = {}\r\n for idx in formatted_docs.keys():\r\n preprocessed_docs[idx] = preprocess(formatted_docs[idx])\r\n return preprocessed_docs","def load_flattened_documents(data_dir: str, docids: Set[str]) -> Dict[str, List[str]]:\n unflattened_docs = load_documents(data_dir, docids)\n flattened_docs = dict()\n for doc, unflattened in unflattened_docs.items():\n flattened_docs[doc] = list(chain.from_iterable(unflattened))\n return flattened_docs","def build(self,documents):\n\t\tself.vectorKeywordIndex = self.getVectorKeywordIndex(documents)\n\n\t\tself.documentVectors = [self.createVector(document) for document in documents]","def _build_token_dict(self, corpus: List[List[str]], min_count: int = 3):\n token2idx = {\n self.token_pad: 0,\n self.token_unk: 1,\n self.token_bos: 2,\n self.token_eos: 3\n }\n\n token2count = {}\n for sentence in corpus:\n for token in sentence:\n count = token2count.get(token, 0)\n token2count[token] = count + 1\n\n # 按照词频降序排序\n sorted_token2count = sorted(token2count.items(),\n key=operator.itemgetter(1),\n reverse=True)\n token2count = collections.OrderedDict(sorted_token2count)\n\n for token, token_count in token2count.items():\n if token not in token2idx and token_count >= min_count:\n token2idx[token] = len(token2idx)\n\n self.token2idx = token2idx\n self.idx2token = dict([(value, key)\n for key, value in self.token2idx.items()])\n logging.debug(f\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\")\n self.dataset_info['token_count'] = len(self.token2idx)","def update_words(data, book_num):\n\tglobal word_count\n\t#find count of each word in the book and update the dictionary\n\tfor words in data:\n\t\tword_count[words][book_num] = (word_count.get(words,0)[book_num] + 1)\n\t#print(word_count)","def generate_dict(self):\n dict = defaultdict(list)\n for i in range(self.no_of_docs-1):\n doc_txt = self.doc_to_df(i)\n #assign key to index in dictionary and its locations as tuples(docid,line,wordpos) as the values\n for j in range(len(doc_txt)):\n for k in range(doc_txt.shape[1]):\n key = doc_txt[k][j]\n dict[key].append((i,j,k))","def parse_doc(self, doc_as_list):\n tweet_id = doc_as_list[0]\n tweet_date = doc_as_list[1]\n full_text = doc_as_list[2]\n url = doc_as_list[3]\n retweet_text = doc_as_list[4]\n retweet_url = doc_as_list[5]\n quote_text = doc_as_list[6]\n quote_url = doc_as_list[7]\n term_dict = {}\n tokenized_text = self.parse_sentence(full_text)\n doc_length = len(tokenized_text) # after text operations.\n\n for i, term in enumerate(tokenized_text):\n if term not in term_dict.keys():\n term_dict[term] = [1, [i]]\n else:\n term_dict[term][0] += 1\n term_dict[term][1].append(i)\n\n document = Document(tweet_id, tweet_date, full_text, url, retweet_text, retweet_url, quote_text,\n quote_url, term_dict, doc_length)\n return document","def set(self, doc, fields_values):\n fields_values = Object.from_bson(fields_values)\n for k,v in fields_values.items():\n self._set(doc, k.split('.'), v)\n impl = self._impl(doc)\n return impl.update({'_id':doc._id}, {'$set':fields_values})","def extract(self, documents):\n\n # Feature vector to return\n features = np.zeros((len(documents), len(self.idx_to_word)))\n\n # Raise an exception if 'extract' is called before 'preprocess'\n if len(self.word_to_idx) == 0 or len(self.idx_to_word) == 0:\n raise Exception(\"Dictionary not initialised.\")\n\n # Iterate over all documents\n for idx, doc in enumerate(documents):\n # Split the doc into a list of words\n words = extract_words(doc)\n\n # For each word\n for w in words:\n # Calculate it's frequency, however, keep in mind\n # that this word may not have been in the training\n # corpus. In that case, ignore the word.\n ''' YOUR CODE HERE '''\n try:\n features[idx][self.word_to_idx[w]] = words.count(w)\n except KeyError:\n pass\n\n ''' END CODE FOR THIS LOOP '''\n\n # Divide the vector by the total number of words in the document to\n # normalize the frequencies.\n ''' YOUR CODE HERE '''\n features[idx] = features[idx]/len(words)\n ''' END CODE FOR THIS LOOP '''\n\n return features","def _vector_mapping(self) -> dict:\n words = set()\n for file in os.listdir(self.processed_path):\n doc_path = f\"{self.processed_path}/{file}\"\n with open(doc_path, 'r') as f:\n text_words = f.readline().split()\n words = words.union(set(text_words))\n words = list(words)\n words.sort()\n\n return dict(zip(words, range(len(words))))","def add(self, token_docid):\n token = token_docid[0]\n doc_id = token_docid[1]\n # collapse identical tokens together\n if token in self.posting:\n self.posting[token].append(doc_id)\n else:\n self.posting[token] = [doc_id]","def __call__(self, doc: Doc) -> Doc:\n for val in self._get_vals(doc):\n key = self._get_key(val)\n try:\n self._table.get(key).append(val)\n except AttributeError:\n self._table.set(key, [val])\n self._size += 1\n return super().__call__(doc)","def __parse_corpus(self, corpus):\n corpus = self.__handle_corpus_unkwon_words(corpus)\n start_token = ' '.join([NGramModel.START_SENTENCE_TOKEN]*(self.__n-1))\n word_list = corpus.replace(NGramModel.START_SENTENCE_TOKEN, start_token).split()\n \n for n in range(1, self.__n+1): \n self.__ngram_counts[n] = {}\n for ngram, count in Counter(self.__generate_n_grams(word_list, n)).items():\n self.__ngram_counts[n][' '.join(ngram)] = count","def documents(self, **kw):\r\n \r\n doc_reader = self.doc_reader\r\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))","def merge_all_claims_norm_dicts_for_docs(): \n# docs_norm_scores_dicts_path = base_path+\"\\\\docs_norm_scores_dicts\"\n docs_norm_scores_dicts_path = linux_base_path+\"/docs_norm_scores_dicts\"\n# all_claims_norms_scores_merged_dict = base_path +\"\\\\all_claims_norms_scores_merged_dict\"\n all_claims_norms_scores_merged_dict = linux_base_path +\"/all_claims_norms_scores_merged_dict\"\n for alpha in range(0,11,1):\n for beta in range(0,10,1):\n docs_scores_all_claims = {}\n for filename in os.listdir(docs_norm_scores_dicts_path):\n (alpha_f,beta_f)=turn_to_float([alpha,beta])\n if \"_alpha_\"+str(alpha_f)+\"_\" in filename and \"_beta_\"+str(beta_f)+\"_\" in filename:\n curr_dict = read_pickle(docs_norm_scores_dicts_path+\"/\"+filename)\n docs_scores_all_claims = dict(docs_scores_all_claims.items() + curr_dict.items()) #merge dicts\n save_pickle(all_claims_norms_scores_merged_dict+\"/docs_norm_scores_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f),docs_scores_all_claims)","def tokenize_replace_pos(doc_list, language_code, replace_pos,\n core_num=multiprocessing.cpu_count()):\n param = [[d, language_code, replace_pos] for d in doc_list]\n pool = multiprocessing.Pool(core_num)\n return pool.map(_tokenize_replace_pos4map, param)","def refine_tokens( self, tokens ):\n k = 1.75\n b = 0.75\n stop_words_file = \"stop_words.txt\"\n all_stopwords = list()\n refined_tokens_sources = dict()\n \n # collect all the stopwords\n with open( stop_words_file ) as file:\n lines = file.read()\n all_stopwords = lines.split( \"\\n\" )\n \n for source in tokens:\n refined_tokens = dict()\n files = dict()\n inverted_frequency = dict()\n file_id = -1\n total_file_length = 0\n for item in tokens[ source ]:\n file_id += 1\n file_tokens = tokens[ source ][ item ].split(\" \")\n if source in \"name_desc_edam_help\":\n file_tokens = utils._clean_tokens( file_tokens, all_stopwords )\n total_file_length += len( file_tokens )\n term_frequency = dict()\n for token in file_tokens:\n if token is not '':\n file_ids = list()\n if token not in inverted_frequency:\n file_ids.append( file_id )\n else:\n file_ids = inverted_frequency[ token ]\n if file_id not in file_ids:\n file_ids.append( file_id )\n inverted_frequency[ token ] = file_ids\n # for term frequency\n if token not in term_frequency:\n term_frequency[ token ] = 1\n else:\n term_frequency[ token ] += 1\n files[ item ] = term_frequency\n N = len( files )\n average_file_length = float( total_file_length ) / N\n # find BM25 score for each token of each tool. It helps to determine\n # how important each word is with respect to the tool and other tools\n for item in files:\n file_item = files[ item ]\n file_length = len( file_item )\n for token in file_item:\n tf = file_item[ token ]\n # normalize the term freq of token for each document\n tf = float( tf ) / file_length\n idf = np.log2( N / len( inverted_frequency[ token ] ) )\n alpha = ( 1 - b ) + ( float( b * file_length ) / average_file_length )\n tf_star = tf * float( ( k + 1 ) ) / ( k * alpha + tf )\n tf_idf = tf_star * idf\n file_item[ token ] = tf_idf\n # filter tokens based on the BM25 scores and stop words. Not all tokens are important\n for item in files:\n file_tokens = files[ item ]\n tokens_scores = [ ( token, score ) for ( token, score ) in file_tokens.items() ]\n sorted_tokens = sorted( tokens_scores, key=operator.itemgetter( 1 ), reverse=True )\n refined_tokens[ item ] = sorted_tokens\n tokens_file_name = 'tokens_' + source + '.txt'\n token_file_path = os.path.join( os.path.dirname( self.tools_data_path ) + '/' + tokens_file_name )\n with open( token_file_path, 'w' ) as file:\n file.write( json.dumps( refined_tokens ) )\n file.close()\n refined_tokens_sources[ source ] = refined_tokens\n return refined_tokens_sources","def build_ngram_index(tokenized_documents, ngrams):\n dictionary = {}\n\n doc_ngrams = {}\n for doc in tokenized_documents:\n ngrams_freq = {}\n\n measures = nltk.collocations.BigramAssocMeasures()\n finder = BigramCollocationFinder.from_words(tokenized_documents[doc])\n freqs = finder.ngram_fd\n for ngram in freqs:\n ngrams_freq[ngram] = freqs[ngram]\n \n measures = nltk.collocations.TrigramAssocMeasures()\n finder = TrigramCollocationFinder.from_words(tokenized_documents[doc])\n freqs = finder.ngram_fd\n for ngram in freqs:\n ngrams_freq[ngram] = freqs[ngram]\n\n doc_ngrams[doc] = ngrams_freq\n\n for ngram in ngrams:\n dictionary[ngram] = [0]\n for doc in doc_ngrams:\n if ngram in doc_ngrams[doc]:\n dictionary[ngram][0] += doc_ngrams[doc][ngram]\n dictionary[ngram].append((doc, doc_ngrams[doc][ngram]))\n \n return dictionary"],"string":"[\n \"def add_documents(self, docs):\\n for sent in docs:\\n sent = map(self.process_token, sent)\\n self._token_count.update(sent)\",\n \"def add_documents(self, docs):\\n if 'sentences' in docs:\\n for sent in docs.sentences:\\n sent = map(self.process_token, [t for t in sent.tokens if not t.is_stopword])\\n self._token_count.update(sent)\\n\\n else:\\n sent = list(map(self.process_token, [t for t in docs.tokens if not t.is_stopword]))\\n self._token_count.update(sent)\",\n \"def add_to_dict(self, tokens):\\n# TODO: ?add normalization of a token?\\n for token in tokens:\\n if self.embedding_words and (token not in self.embedding_words):\\n continue\\n self.freq[token] += 1\\n if token not in self.tok2ind:\\n index = len(self.tok2ind)\\n self.tok2ind[token] = index\\n self.ind2tok[index] = token\",\n \"def update(tokens):\\n global TOKENS\\n\\n for token_id in tokens:\\n\\n if token_id not in TOKENS:\\n TOKENS[token_id] = {}\\n\\n if isinstance(tokens, dict):\\n token_info = tokens[token_id]\\n if token_info is None:\\n token_info = {}\\n\\n alias = token_info.get(\\\"alias\\\")\\n if alias is not None:\\n TOKENS[token_id][\\\"alias\\\"] = alias\\n\\n decimals = token_info.get(\\\"decimals\\\")\\n if decimals is not None:\\n TOKENS[token_id][\\\"decimals\\\"] = decimals\",\n \"def intern_documents(documents: Dict[str, List[List[str]]], word_interner: Dict[str, int], unk_token: str):\\n ret = dict()\\n unk = word_interner[unk_token]\\n for docid, sentences in documents.items():\\n ret[docid] = [[word_interner.get(w, unk) for w in s] for s in sentences]\\n return ret\",\n \"def update_existing(doc_data_tples):\\n def per_doc(doc, data_tples):\\n def per_field(data_tple):\\n field, datas = data_tple\\n map(_do_append_field(doc, field), datas)\\n map(per_field, data_tples)\\n return doc\\n\\n __docs = ( (per_doc(doc, data_tples), data_tples) for doc,data_tples in doc_data_tples )\\n return __docs\",\n \"def updateDocumentAll(self, documents):\\n docs = []\\n for document in documents:\\n if isinstance(document, couch.Document):\\n document = document.getData()\\n\\n # these are required params\\n if \\\"_id\\\" not in document or \\\"_rev\\\" not in document:\\n raise Exception(\\\"Both _id & _rev fields are required!\\\")\\n\\n docs.append(document)\\n\\n return self.client.post(self.name +\\\"/_bulk_docs\\\", None,\\n {\\\"docs\\\": docs}).getBodyData()\",\n \"def update_from_document(self, document_path):\\n with open(document_path, 'r') as document_file:\\n for sentence in document_file:\\n words = sentence.strip().split()\\n for word in words:\\n self._add_new_word(word)\",\n \"def preprocess(self, documents):\\n\\n # A dict storing the frequency of each word\\n word_freq = {}\\n\\n # Iterate for each document\\n for doc in documents:\\n # Split the document into a list of words and iterate on it\\n for w in extract_words(doc):\\n # Update word frequencies\\n '''YOUR CODE HERE'''\\n if w not in word_freq.keys():\\n word_freq[w] = 1\\n else:\\n word_freq[w] += 1\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n\\n # A set of words with frequency less than 'self.min_freq'\\n remove_words = set()\\n\\n # Check frequency of each word and add to 'remove_words'\\n # if it's frequency is below self.min_freq\\n\\n ''' YOUR CODE HERE '''\\n for w in word_freq.keys():\\n if word_freq[w] < self.min_freq:\\n remove_words.add(w)\\n\\n # Delete the words in 'remove_words' from 'word_freq'\\n for w in remove_words:\\n del word_freq[w]\\n\\n # Fill 'self.word_to_idx' and 'self.idx_to_word' for\\n # each word in 'word_freq' (dicts are explained above)\\n\\n i = 0\\n for w in word_freq.keys():\\n self.word_to_idx[w] = i\\n self.idx_to_word[i] = w \\n i += 1\\n\\n ''' END YOUR CODE HERE '''\",\n \"def fit(self, documents):\\n # Get a list of all the unique tokens that appear\\n vocab = list({\\n token for doc in documents\\n for token in self.tokenizer(doc)\\n if token not in self._word2index\\n })\\n\\n # This is UNK, START, END, and PAD.\\n nb_special_tokens = 4\\n\\n # First, we map token -> ID, leaving the first slots for special tokens\\n self._word2index.update({\\n word: idx\\n for idx, word in enumerate(vocab, nb_special_tokens)\\n })\\n\\n # Next, we invert this map, which we can do since it was built from\\n # unique vocabulary elements and is by definition bijective.\\n self._index2word.update({\\n idx: word\\n for word, idx in self._word2index.items()\\n })\\n\\n return self\",\n \"def multiple_document_processing(self) -> List:\\n batch_list = []\\n for doc, idx in self.__documents:\\n entities_idx = {'idx': idx}\\n entities_result = self.create_entity(document=doc)\\n word_cleaned = self.clean_words(doc)\\n entities_idx[self.key_spacy_text] = str(word_cleaned)\\n entities_idx.update(entities_result)\\n batch_list.append(entities_idx)\\n return batch_list\",\n \"def get_doc_dicts(self, doc_ids):\\n pass\",\n \"def updateMultipleDocuments(cred, payload):\\n\\n url = cred.base_url + \\\"documents:commit\\\"\\n data = { 'writes': [] }\\n\\n for path, fieldData in payload.iteritems():\\n pathData = createFirestoreDataObject(cred, path, fieldData)\\n data['writes'].append(pathData)\\n \\n makeRequest(cred, url, 'POST', data)\",\n \"def add_doc_in_posting_list(word_posting_list, docs):\\n for doc_score in docs:\\n if doc_score[\\\"doc\\\"] in word_posting_list.keys():\\n word_posting_list[doc_score[\\\"doc\\\"]] = int(doc_score[\\\"score\\\"]) + int(word_posting_list[doc_score[\\\"doc\\\"]])\\n else:\\n word_posting_list[doc_score[\\\"doc\\\"]] = doc_score[\\\"score\\\"]\",\n \"def load(self, documents, uniquify=False):\\n assert documents, \\\"missing list of documents, text single doc per line\\\"\\n assert isinstance(documents, list), \\\"documents must be list\\\"\\n assert isinstance(documents[0], list), \\\"each document is also a list\\\"\\n #--------------------------------------------------------------------------------------------\\n\\n def _get_new_counts(document):\\n return Counter(document) if not uniquify else Counter(list(set(document)))\\n\\n for idx, document in enumerate(documents):\\n new_counter = _get_new_counts(document)\\n self.counter.update(new_counter)\\n if idx % 1000 == 0:\\n print(\\\"load: {}\\\\r\\\".format(idx), end='')\\n return self\",\n \"def parse_doc(self, doc_as_list):\\n\\n tweet_id = doc_as_list[0]\\n tweet_date = doc_as_list[1]\\n full_text = doc_as_list[2]\\n url = doc_as_list[3]\\n indice = doc_as_list[4]\\n retweet_text = doc_as_list[5]\\n retweet_url = doc_as_list[6]\\n retweet_indice = doc_as_list[7]\\n quote_text = doc_as_list[8]\\n quote_url = doc_as_list[9]\\n quoted_indice = doc_as_list[10]\\n retweet_quoted_text = doc_as_list[11]\\n retweet_quoted_url = doc_as_list[12]\\n retweet_quoted_indice = doc_as_list[13]\\n\\n term_dict = {}\\n\\n tokenized_text = self.parse_sentence(full_text)\\n tokenized_quote = self.parse_sentence(quote_text)\\n # tokenized_url = self.handle_url(url)\\n\\n\\n doc_length = len(tokenized_text) # after text operations - length of full_text\\n\\n new_tokenized_text = tokenized_text + tokenized_quote\\n\\n # spell checker\\n # new_tokenized_text = self.spell.update(new_tokenized_text)\\n\\n for term in new_tokenized_text:\\n if term is not \\\"\\\": # or (term.isalpha() and len(term) == 1)\\n if term not in term_dict:\\n term_dict[term] = 1\\n else:\\n term_dict[term] += 1\\n\\n document = Document(tweet_id, tweet_date, full_text, url, retweet_text, retweet_url, quote_text,\\n quote_url, term_dict, doc_length)\\n return document\",\n \"def prepare_dictionary_from_docs(self):\\n if os.path.exists(self.DICT_PATH):\\n return True\\n self.logger.info(\\\"START PREPARING DICT\\\")\\n for fn in os.listdir(self.wiki_path):\\n self.logger.info(\\\"dict update {0}\\\".format(fn))\\n content = self.get_processed_content(fn)\\n self.dictionary.add_documents([content])\\n self.dictionary.filter_extremes(no_below=20, no_above=0.1, keep_n=100000)\\n self.dictionary.compactify()\\n self.dictionary.save(self.DICT_PATH)\\n return True\",\n \"def get_dict(cleaned_docs):\\n data = []\\n for doc in cleaned_docs:\\n data += doc\\n return list(set(data))\",\n \"def transform(self, docs):\\n return [doc for doc in docs]\",\n \"def doc2bow(self, document, allow_update=False, return_missing=False):\\n\\n doc=[t.text for t in document.tokens]\\n\\n if isinstance(doc, string_types):\\n raise TypeError(\\\"doc2bow expects an array of unicode tokens on input, not a single string\\\")\\n\\n # Construct (word, frequency) mapping.\\n counter = defaultdict(int)\\n for w in doc:\\n counter[w if isinstance(w, str) else str(w, 'utf-8')] += 1\\n\\n token2id = self.token2id\\n if allow_update or return_missing:\\n missing = sorted(x for x in iteritems(counter) if x[0] not in token2id)\\n if allow_update:\\n for w, _ in missing:\\n # new id = number of ids made so far;\\n # NOTE this assumes there are no gaps in the id sequence!\\n token2id[w] = len(token2id)\\n result = {token2id[w]: freq for w, freq in iteritems(counter) if w in token2id}\\n\\n if allow_update:\\n self.num_docs += 1\\n self.num_pos += sum(itervalues(counter))\\n self.num_nnz += len(result)\\n # keep track of document and collection frequencies\\n for tokenid, freq in iteritems(result):\\n self.cfs[tokenid] = self.cfs.get(tokenid, 0) + freq\\n self.dfs[tokenid] = self.dfs.get(tokenid, 0) + 1\\n\\n # return tokenids, in ascending id order\\n result = sorted(iteritems(result))\\n if return_missing:\\n return result, dict(missing)\\n else:\\n return result\",\n \"def _build_token_dict(self, corpus: List[List[str]]):\\n self.token2idx = self.load_from_vocab_file(self.vocab_path)\\n self.idx2token = dict([(value, key)\\n for key, value in self.token2idx.items()])\\n logging.debug(f\\\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\\\")\\n self.dataset_info['token_count'] = len(self.token2idx)\",\n \"def docs2ids(self):\\n self.docs = [ [self.vocab[word] for word in doc] for doc in self.docs]\",\n \"def update_all(cls, documents: List[dict]) -> (List[dict], List[dict]):\\n if not documents:\\n raise ValidationFailed([], message=\\\"No data provided.\\\")\\n\\n if not isinstance(documents, list):\\n raise ValidationFailed(documents, message=\\\"Must be a list.\\\")\\n\\n new_documents = copy.deepcopy(documents)\\n\\n errors = cls.validate_and_deserialize_update(new_documents)\\n if errors:\\n raise ValidationFailed(documents, errors)\\n\\n try:\\n if cls.logger.isEnabledFor(logging.DEBUG):\\n cls.logger.debug(f\\\"Updating {new_documents}...\\\")\\n previous_documents, updated_documents = cls._update_many(new_documents)\\n if cls.logger.isEnabledFor(logging.DEBUG):\\n cls.logger.debug(f\\\"Documents updated to {updated_documents}.\\\")\\n return (\\n [cls.serialize(document) for document in previous_documents],\\n [cls.serialize(document) for document in updated_documents],\\n )\\n except pymongo.errors.DuplicateKeyError:\\n raise ValidationFailed(\\n [cls.serialize(document) for document in documents],\\n message=\\\"One document already exists.\\\",\\n )\",\n \"def load_documents(data_dir: str, docids: Set[str] = None) -> Dict[str, List[List[str]]]:\\n if os.path.exists(os.path.join(data_dir, 'docs.jsonl')):\\n assert not os.path.exists(os.path.join(data_dir, 'docs'))\\n return load_documents_from_file(data_dir, docids)\\n\\n docs_dir = os.path.join(data_dir, 'docs')\\n res = dict()\\n if docids is None:\\n docids = sorted(os.listdir(docs_dir))\\n else:\\n docids = sorted(set(str(d) for d in docids))\\n for d in docids:\\n with open(os.path.join(docs_dir, d), 'r') as inf:\\n lines = [l.strip() for l in inf.readlines()]\\n lines = list(filter(lambda x: bool(len(x)), lines))\\n tokenized = [list(filter(lambda x: bool(len(x)), line.strip().split(' '))) for line in lines]\\n res[d] = tokenized\\n return res\",\n \"def load_documents_from_file(data_dir: str, docids: Set[str] = None) -> Dict[str, List[List[str]]]:\\n docs_file = os.path.join(data_dir, 'docs.jsonl')\\n documents = load_jsonl(docs_file)\\n documents = {doc['docid']: doc['document'] for doc in documents}\\n res = dict()\\n if docids is None:\\n docids = sorted(list(documents.keys()))\\n else:\\n docids = sorted(set(str(d) for d in docids))\\n for d in docids:\\n lines = documents[d].split('\\\\n')\\n tokenized = [line.strip().split(' ') for line in lines]\\n res[d] = tokenized\\n return res\",\n \"def initialize_terms_and_postings():\\n global dictionary, postings\\n for id in document_filenames:\\n document = getDocumentContent(document_filenames[id])\\n if(document_filenames[id].rfind(\\\".pdf\\\") == len(document_filenames[id]) - 4):\\n terms = tokenize(document.encode('utf-8'))\\n if(document_filenames[id].rfind(\\\".txt\\\") == len(document_filenames[id]) - 4):\\n terms = tokenize(document)\\n if(document_filenames[id].rfind(\\\".docx\\\") == len(document_filenames[id]) - 5):\\n terms = tokenize(document)\\n if(document_filenames[id].rfind(\\\".pptx\\\") == len(document_filenames[id]) - 5):\\n terms = tokenize(document)\\n unique_terms = set(terms)\\n dictionary = dictionary.union(unique_terms)\\n for term in unique_terms:\\n postings[term][id] = terms.count(term) # the value is the\\n # frequency of the\\n # term in the\\n # document\",\n \"def _create_dictionary(self, document_set):\\n words = self._normalize_words(document_set.words)\\n unique_words = frozenset(words)\\n return dict((word, idx) for idx, word in enumerate(unique_words))\",\n \"def set_keyword_map(self):\\n \\n ret = defaultdict(list)\\n for idx, doc in enumerate(self.docs):\\n for token in doc:\\n if token in self.dictionary.token2id:\\n ret[token].append(idx)\\n \\n self.keyword_map = ret\\n return ret\",\n \"def clean_docs(self,docs):\\n\\n # Remove numbers, but not words that contain numbers.\\n docs = [[token for token in doc if not token.isnumeric()] for doc in docs]\\n\\n # Remove words that are only one character.\\n docs = [[token for token in doc if len(token) > 1 and token not in stop_words] for doc in docs]\\n\\n # lemmatizer = WordNetLemmatizer()\\n # docs = [[lemmatizer.lemmatize(token) for token in doc] for doc in docs]\\n\\n # Add bigrams and trigrams to docs (only ones that appear 20 times or more).\\n bigram = Phrases(docs, min_count=20)\\n for idx in range(len(docs)):\\n for token in bigram[docs[idx]]:\\n if '_' in token:\\n # Token is a bigram, add to document.\\n docs[idx].append(token)\\n\\n # Create a dictionary representation of the documents.\\n dictionary = Dictionary(docs)\\n\\n # Filter out words that occur less than 20 documents, or more than 50% of the documents.\\n dictionary.filter_extremes(no_below=20, no_above=0.5)\\n\\n # Bag-of-words representation of the documents.\\n corpus = [dictionary.doc2bow(doc) for doc in docs]\\n\\n return docs,dictionary,corpus\",\n \"def add_new_doc(self, document, documents_list_length=10000):\\n\\n try:\\n document_dictionary = document.term_doc_dictionary\\n # self.countDoc += 1\\n for term in document_dictionary.keys():\\n if self.stemming == 'y':\\n my_stemmer = Stemmer()\\n term = my_stemmer.stem_term(term)\\n # Update inverted index and posting\\n if term not in self.inverted_idx.keys():\\n self.inverted_idx[term] = [1, [\\n (document_dictionary[term], document.tweet_id)]] # amount of doc, freq in the doc, doc id.\\n\\n else:\\n self.inverted_idx[term][0] += 1 # amount of doc\\n self.inverted_idx[term][1].append((document_dictionary[term],\\n document.tweet_id)) # freq in the doc # doc id\\n\\n if term not in self.postingDict.keys():\\n self.postingDict[term] = [(document.tweet_id, document_dictionary[term])]\\n else:\\n self.postingDict[term].append((document.tweet_id, document_dictionary[term]))\\n # self.countTweet -= 1\\n\\n if document.tweet_id not in self.tweet_dict.keys():\\n self.tweet_dict[document.tweet_id] = [[term, document_dictionary[term]], 1,\\n 0] # [term,freq in tweet], amount of unique terms in tweet, amount of terms in tweet\\n elif document_dictionary[term] > self.tweet_dict[document.tweet_id][0][\\n 1]: # tweet exist, compering between freq in two terms\\n if self.tweet_dict[document.tweet_id][0][\\n 1] == 1: # before change term check if the last term is unique\\n self.tweet_dict[document.tweet_id][\\n 1] += 1 # last term is unique: add to the amount of uniqe terms in tweet\\n self.tweet_dict[document.tweet_id][0] = [term,\\n document_dictionary[term]] # change between the terms\\n self.tweet_dict[document.tweet_id][2] += 1\\n elif document_dictionary[term] == 1: # tweet exist, not most common, check if unique\\n self.tweet_dict[document.tweet_id][1] += 1\\n self.tweet_dict[document.tweet_id][2] += 1\\n except:\\n # print('problem in indexer : add_new_doc')\\n # print(traceback.print_exc())\\n pass\",\n \"def add(self, document):\\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\\n if not token.isalpha():\\n continue\\n\\n if token in self.stopwords:\\n continue\\n \\n if self.stemmer:\\n token = self.stemmer.stem(token)\\n \\n if self.__unique_id not in self.index[token]:\\n self.index[token].append(self.__unique_id)\\n \\n self.documents[self.__unique_id] = document\\n self.__unique_id += 1\",\n \"def preprocess(self, documents):\\n\\n # Store the total number of documents\\n num_docs = np.float(len(documents))\\n\\n # A dict storing the frequency of each word across all documents\\n total_word_freq = {}\\n\\n # A dict storing the number of documents that word appears in\\n doc_word_freq = {}\\n\\n # Iterate over all documents\\n for doc in documents:\\n # Split the string into a list of words\\n words = extract_words(doc)\\n\\n # Update the 'total_word_freq' dict using all words in 'words'\\n for w in words:\\n ''' YOUR CODE HERE '''\\n if w not in total_word_freq.keys():\\n total_word_freq[w] = 1\\n else:\\n total_word_freq[w] += 1\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n # Update the 'doc_word_freq' dict. Remember to only add '1' corresponding to\\n # each word in a document. In case a word appears twice in a document, then\\n # it should be ignored. We use the set() data structure to achieve this.\\n for w in set(words):\\n ''' YOUR CODE HERE '''\\n if w not in doc_word_freq:\\n doc_word_freq[w] = 1\\n else:\\n doc_word_freq[w] += 1\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n # A set of words with total frequency less than 'self.min_freq'\\n remove_words = set()\\n\\n ''' YOUR CODE HERE '''\\n\\n # Check frequency of each word and add to 'remove_words'\\n for w in total_word_freq.keys():\\n if total_word_freq[w] < self.min_freq:\\n remove_words.add(w)\\n\\n # Delete the words in 'remove_words' from 'total_word_freq' and\\n # 'doc_word_freq'.\\n for w in remove_words:\\n del total_word_freq[w]\\n del doc_word_freq[w]\\n\\n # Create a numpy array to store frequencies from which\\n # we can create the 'self.idf' preprocessed numpy array.\\n word_freq_tensor = np.zeros(len(doc_word_freq))\\n\\n # For each word in 'doc_word_freq' dict, update\\n # 'self.word_to_idx' and 'self.idx_to_word' and\\n # 'word_freq_tensor'.\\n i = 0\\n for w in doc_word_freq.keys():\\n self.word_to_idx[w] = i \\n self.idx_to_word[i] = w\\n word_freq_tensor[i] = doc_word_freq[w]\\n i+=1\\n \\n #print(word_freq_tensor.shape)\\n #print(word_freq_tensor)\\n # Calculate 'self.idf' (see hint.pdf for formula)\\n self.idf = -1*np.log(word_freq_tensor/(len(documents)))\\n ''' END YOUR CODE HERE '''\",\n \"def process_new_tokens(tokens,processed_tokens_set, model, dictionary):\\n if hasattr(model, 'using_pretrained') and model.using_pretrained is not None:\\n processed_tokens_set.update(tokens)\\n update_embedding_layer(processed_tokens_set, model, dictionary)\",\n \"def process_document(text):\\n words = preprocess(text)\\n postings = {}\\n for word, ix in words:\\n if word in postings:\\n wordinfo = postings[word]\\n else:\\n wordinfo = {\\\"frequency\\\": 0, \\\"indexes\\\": []}\\n postings[word] = wordinfo\\n wordinfo[\\\"frequency\\\"] += 1\\n wordinfo[\\\"indexes\\\"].append(ix)\\n return postings\",\n \"def pre_process(self, documents):\\n\\n return documents\",\n \"def insert_many(self, documents: Iterable[dict]) -> None:\\n for i, document in enumerate(documents):\\n if isinstance(document, dict):\\n self._store_document(document)\\n else:\\n raise TypeError(\\n f\\\"The document at index {i} was not a dictionary. All documents must be dictionaries.\\\"\\n )\\n self._dump()\",\n \"def _docMapping(self):\\n doc2quests = defaultdict(list)\\n for q, d in self.quest2doc.items():\\n doc2quests[d].append(q)\\n return doc2quests\",\n \"def create_document_dictionary(documents):\\n \\n document_dictionary = dict()\\n for document in documents:\\n document_dictionary[document.cord_uid] = document\\n return document_dictionary\",\n \"def transform4Doc2Vec(docs):\\n\\n # transform documents to be used by doc2Vec\\n documents = []\\n analyzedDocument = namedtuple('AnalyzedDocument', 'words tags')\\n for i, doc in enumerate(docs):\\n # use first line if documents are not tokenized, otherwise next line\\n # words = text.lower().split()\\n tags = [i]\\n documents.append(analyzedDocument(doc, tags))\\n\\n return documents\",\n \"def _create_dictionary(self, document):\\n words = self._normalize_words(document.words)\\n unique_words = frozenset(words)\\n return dict((word, idx) for idx, word in enumerate(unique_words))\",\n \"def enrich(self, lazy_corpus_loader, fileids=None):\\n tag_dict = self.tag_dict\\n word_tag_dict = self.word_tag_dict\\n for word_tag in lazy_corpus_loader.tagged_words(fileids=fileids):\\n word = word_tag[0]\\n tag = word_tag[1]\\n if not tag_dict.get(tag, None):\\n raise KeyError, \\\"Unknown pos-tag: %s\\\" % tag\\n tag_dict = word_tag_dict.get(word, {})\\n tag_dict[tag] = tag_dict.get(tag, 0) + 1\\n word_tag_dict[word] = tag_dict\\n self.word_tag_dict = word_tag_dict\",\n \"def add(self, tokens):\\n\\n for token in tokens:\\n self.vocab.add(token)\\n\\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\\n if leader not in self.frequencies:\\n self.frequencies[leader] = Frequency()\\n\\n self.frequencies[leader].add(token)\",\n \"def set_doc_phrases(doc_phrases, docs, phrases):\\n for doc in docs:\\n if not doc in doc_phrases:\\n doc_phrases[doc] = []\\n doc_phrases[doc] = doc_phrases[doc] + phrases\",\n \"def tokenize_document(doc_info: dict, tokenizer: BertTokenizer, max_doc_length: int = None) -> dict:\\n sub_tokens: List[str] = [] # all sub tokens of a document\\n sentence_map: List[int] = [] # collected tokenized tokens -> sentence id\\n subtoken_map: List[int] = [] # collected tokenized tokens -> original token id\\n\\n word_idx = -1\\n\\n for sentence_id, sentence in enumerate(doc_info['sentences']):\\n for token in sentence:\\n word_idx += 1\\n word_tokens = tokenizer.tokenize(token)\\n sub_tokens.extend(word_tokens)\\n sentence_map.extend([sentence_id] * len(word_tokens))\\n subtoken_map.extend([word_idx] * len(word_tokens))\\n if max_doc_length:\\n num_to_pad = max_doc_length - len(sub_tokens)\\n sub_tokens.extend([\\\"[PAD]\\\"] * num_to_pad)\\n sentence_map.extend([sentence_map[-1]+1] * num_to_pad)\\n subtoken_map.extend(list(range(word_idx+1, num_to_pad+1+word_idx)))\\n # global MAX_LENGTH\\n # if len(sub_tokens) > MAX_LENGTH:\\n # print(len(sub_tokens))\\n # MAX_LENGTH = len(sub_tokens)\\n # print(MAX_LENGTH)\\n # todo(yuxian): need pad speakers?\\n speakers = {subtoken_map.index(word_index): tokenizer.tokenize(speaker)\\n for word_index, speaker in doc_info['speakers']}\\n clusters = [[(subtoken_map.index(start), len(subtoken_map) - 1 - subtoken_map[::-1].index(end))\\n for start, end in cluster] for cluster in doc_info['clusters']]\\n tokenized_document = {'sub_tokens': sub_tokens, 'sentence_map': sentence_map, 'subtoken_map': subtoken_map,\\n 'speakers': speakers, 'clusters': clusters, 'doc_key': doc_info['doc_key']}\\n return tokenized_document\",\n \"def replace_words_fun(self):\\n\\n cleaned_doc = []\\n for word in str(self.doc).split():\\n if word.lower() in self.replacement_list.keys():\\n cleaned_doc.append(self.replacement_list[word.lower()])\\n else:\\n cleaned_doc.append(word)\\n self.doc = ' '.join(cleaned_doc)\",\n \"def get_idf_dict(clean_corpus, tf_list, num_docs):\\n \\n idf_dict = {}\\n for i in range(num_docs):\\n for key in tf_list[i].keys():\\n if key not in idf_dict.keys():\\n idf_dict[key] = 0\\n idf_dict[key] = idf_dict[key] + 1\\n \\n for key in idf_dict.keys():\\n idf_dict[key] = math.log2(num_docs/idf_dict[key])\\n # idf_dict's keys -> all unique tokens in the corpus \\n return idf_dict\",\n \"def initialize_document_frequencies():\\n global document_frequency\\n for term in dictionary:\\n document_frequency[term] = len(postings[term])\",\n \"def preprocess_corpus(corpus, stop_list, stop_words=True, stemm=True, bag_words=True):\\n corpus_preprocessed = list()\\n for element in corpus:\\n new_element = dict()\\n new_element['document'] = preprocess_document(element['text'], stop_list, stop_words, stemm, bag_words)\\n new_element['id'] = element['id']\\n corpus_preprocessed.append(new_element)\\n\\n return corpus_preprocessed\",\n \"def create_tokens_li():\\n cnt=0\\n for file in docs:\\n file_name = open(\\\"./corpus/\\\"+ str(file) + \\\".txt\\\")\\n print(cnt)\\n cnt+=1\\n words = file_name.read()\\n tokens_doc = nltk.word_tokenize(words)\\n tokens_doc = [w.lower() for w in tokens_doc]\\n #tokens_doc = [snowball_stemmer.stem(token) for token in tokens_doc]\\n tokens_doc = [token for token in tokens_doc if token not in nltk.corpus.stopwords.words('english')]\\n tokens_li.append(tokens_doc)\\n\\n\\n #storing in json file\\n with open('savers/tokens.json', 'w') as fp:\\n json.dump(tokens_li, fp)\",\n \"def documents(self, documents):\\n\\n self._documents = documents\",\n \"def documents_to_dict(documents: List[Dict]) -> Dict[str, Dict]:\\n res = {}\\n for doc in documents:\\n res[doc['id']] = doc\\n return res\",\n \"def map_docs(docs_file):\\n word_map = defaultdict(int)\\n doc_count = 0\\n token_count = 0\\n\\n for _, doc_tokens in tokenize(docs_file):\\n doc_count += 1 # count document\\n token_count += len(doc_tokens) # count tokens\\n for token in set(doc_tokens):\\n word_map[token] += 1 # increase inverted index count\\n\\n docs_file.seek(0) # reset file pointer\\n return doc_count, token_count, word_map\",\n \"def updateScores(rankedLists):\\n docToRank = {}\\n for rankedList in rankedLists:\\n\\n f = open(rankedList, 'r')\\n for line in f:\\n documentID = line.split()[2]\\n docno = documentID\\n score = float(line.split()[4])\\n position = int(line.split()[3])\\n docToRank[docno] = (position,score)\\n f.close()\\n client = MongoClient('asr2.iem.technion.ac.il',27017)\\n db = client.asr16\\n documents = db.documents.find({})\\n for document in documents:\\n key = document[\\\"query_id\\\"]+\\\"-\\\"+document[\\\"username\\\"]\\n document['position'] = docToRank[key][0]\\n document['score'] = docToRank[key][1]\\n document['posted_document'] = document['current_document']\\n db.documents.save(document)\",\n \"def merge_docs(self):\",\n \"def run(self, mapping={}, *args, **kwargs):\\n self.processed = 0\\n for batch in self._process_by_batch(self.load(*args, **kwargs)):\\n batch = list(map(lambda doc: self._apply_mapping(doc, mapping), batch))\\n for doc in batch:\\n self._ingest(iterable=doc, doctype=doc[\\\"doctype\\\"])\\n self.processed += 1\\n logger.info(\\\"Added {} documents to the database.\\\".format(self.processed))\",\n \"def make_vocab_from_docs(docs):\\n vocab_words=set()\\n for doc in docs:\\n doc=doc.lower()\\n doc=re.sub(r'-',' ',doc)\\n doc=re.sub(r' +',' ',doc) # turn multiple spaces into a single space\\n doc=re.sub(r'[^a-z ]','',doc) # remove anything that is not a-z or space\\n words=set(doc.split())\\n vocab_words=vocab_words.union(words)\\n vocab=dict(zip(vocab_words,range(len(vocab_words))))\\n return vocab\",\n \"def _prepare_analysis_input(self, documents):\\n subdoc_to_doc_map = {}\\n wordtype_to_number = {}\\n number_to_wordtype = []\\n wordtypes = {}\\n \\n # prevent duplicating work\\n if os.path.exists(self.wordtype_file):\\n return\\n \\n try:\\n # First find singletons\\n if self.remove_singletons:\\n word_type_count_threshold = max(1, int(math.log(documents.count(), 10)) - 2)\\n temp_word_type_counts = {}\\n for doc_index, doc in enumerate(documents):\\n tokens = self.tokenize(doc.get_content())\\n for token, token_start in tokens:\\n temp_word_type_counts[token] = temp_word_type_counts.setdefault(token, 0) + 1\\n for word_type, count in temp_word_type_counts.iteritems(): # add singletons to stopword list\\n if count <= word_type_count_threshold:\\n self._excluded_words[word_type] = True\\n with io.open(self.excluded_words_file, 'w', encoding='utf-8') as ex_f:\\n ex_f.write(unicode(json.dumps(self._excluded_words)))\\n \\n haltwords = dict(self.stopwords)\\n haltwords.update(self._excluded_words)\\n # Second find bigrams, iterate through documents and train.\\n if self.find_bigrams:\\n from import_tool.analysis.bigram_finder import BigramFinder\\n bigram_finder = BigramFinder(stopwords=haltwords)\\n for doc_index, doc in enumerate(documents):\\n bigram_finder.train(doc_index, self.tokenize(doc.get_content()))\\n bigram_finder.print()\\n \\n # Third, we're going to stem words\\n if self.stem_words:\\n from import_tool.analysis.stemmer import Stemmer\\n stemmer = Stemmer(self._working_dir, self.base_dir)\\n \\n # for each document tokenize and map tokens to numbers to avoid regex problems before passing data to Mallet\\n with io.open(self.mallet_input_file, 'w', encoding='utf-8') as w:\\n with io.open(self.start_index_file, 'w', encoding='utf-8') as w2:\\n count = 0\\n subcount = 0\\n for doc_index, doc in enumerate(documents):\\n doc_content = unicode(doc.get_content())\\n count += 1\\n subdocuments = self.create_subdocuments(doc_index, doc_content)\\n token_start_index_offset = 0 # needed to make sure the start index remains correct once the document is re-merged\\n for subdoc_name, subdoc_content in subdocuments:\\n if subcount > 0:\\n w2.write(u'\\\\n')\\n subcount += 1\\n subdoc_to_doc_map[subdoc_name] = doc_index\\n tokens = self.tokenize(subdoc_content)\\n \\n if self.find_bigrams:\\n tokens = bigram_finder.combine(tokens, subdoc_content)\\n \\n token_numbers = []\\n token_start_indices = []\\n only_tokens = []\\n tokens_temp = []\\n for tok, tok_start in tokens:\\n only_tokens.append(tok)\\n tokens_temp.append([tok, tok_start + token_start_index_offset])\\n tokens = tokens_temp\\n tokens_temp = None\\n if self.stem_words:\\n stemmed_tokens = stemmer.stem(only_tokens)\\n else:\\n stemmed_tokens = only_tokens\\n for tup, tok_stem in zip(tokens, stemmed_tokens):\\n tok, tok_start = tup\\n wordtypes[tok] = True\\n wordtypes[tok_stem] = True\\n try:\\n tok_num = wordtype_to_number[tok_stem]\\n except:\\n tok_num = len(wordtype_to_number)\\n number_to_wordtype.append(tok_stem)\\n wordtype_to_number[tok_stem] = tok_num\\n token_numbers.append(unicode(tok_num))\\n token_start_indices.append([tok, tok_start])\\n text = u' '.join(token_numbers)\\n w.write(u'{0} all {1}\\\\n'.format(subdoc_name, text))\\n w2.write(unicode(json.dumps(token_start_indices)))\\n token_start_index_offset += len(subdoc_content)\\n for tok, tok_start in tokens:\\n try:\\n assert doc_content[tok_start:tok_start+len(tok)].lower() == tok.lower()\\n except:\\n print(tok_start)\\n print(len(tok))\\n print('\\\"'+doc_content[tok_start:tok_start+len(tok)].lower()+'\\\"')\\n print('\\\"'+tok.lower()+'\\\"')\\n raise\\n if not count:\\n raise Exception('No files processed.')\\n # record which subdocuments belong to which documents\\n with io.open(self.subdoc_to_doc_map_file, 'w', encoding='utf-8') as w:\\n w.write(unicode(json.dumps(subdoc_to_doc_map)))\\n with io.open(self.wordtype_to_number_file, 'w', encoding='utf-8') as w:\\n w.write(unicode(json.dumps(wordtype_to_number)))\\n with io.open(self.number_to_wordtype_file, 'w', encoding='utf-8') as w:\\n w.write(unicode(json.dumps(number_to_wordtype)))\\n with io.open(self.wordtype_file, 'w', encoding='utf-8') as w:\\n w.write(unicode(json.dumps(wordtypes)))\\n except: # cleanup\\n self._cleanup(self.mallet_input_file)\\n self._cleanup(self.subdoc_to_doc_map_file)\\n self._cleanup(self.wordtype_to_number_file)\\n self._cleanup(self.number_to_wordtype_file)\\n self._cleanup(self.wordtype_file)\\n self._cleanup(self.excluded_words_file)\\n raise\",\n \"def current_word_PL(current_word, file_reader_last_read_list, doc_dict, nb_doc):\\n word_posting_list = {} # { key = doc , value = score }\\n for idx, file_reader_last_read in enumerate(file_reader_last_read_list):\\n if file_reader_last_read[\\\"last_read\\\"][\\\"word\\\"] == current_word:\\n docs = file_reader_last_read[\\\"last_read\\\"][\\\"doc_score_list\\\"]\\n add_doc_in_posting_list(word_posting_list=word_posting_list, docs=docs)\\n file_reader_last_read_list[idx]=read_line_and_update(file_reader_and_last_read=file_reader_last_read)\\n for key, value in word_posting_list.items():\\n tf = float(value) / doc_dict[int(key)]\\n idf = math.log((float(nb_doc)/len(word_posting_list)),2)\\n score = tf*idf\\n word_posting_list[key]=score \\n word_posting_list = sort_and_cast_doc_in_posting_list(word_posting_list=word_posting_list)\\n return word_posting_list\",\n \"async def put_documents(self, collection, documents):\\n await self.ensure_collection(collection)\\n try:\\n if SOLR_COMMIT_WITHIN:\\n params = {'commitWithin': SOLR_COMMIT_WITHIN}\\n else:\\n params = {'commit': 'true'}\\n await self.post(\\n '/v2/collections/{}/update'.format(collection),\\n params=params, json_data=documents\\n )\\n logger.info('Successfully indexed {} documents to collection {}'\\n .format(len(documents), collection))\\n except SolrError:\\n logger.warning('Failed to put {} documents to collection {}'\\n .format(len(documents), collection))\\n raise\",\n \"def from_documents(cls, documents):\\n # return cls.from_words(_itertools.chain(*documents))\\n return cls.from_words(\\n cls._build_new_documents(documents, cls.default_ws, pad_right=True)\\n )\",\n \"def add_new_doc(self, document, end_of_corpus):\\n max_tf = 0\\n unique_terms_counter = 0\\n document_dictionary = document.term_doc_dictionary\\n # Go over each term in the doc\\n for term in document_dictionary:\\n try:\\n # Update inverted index and posting\\n if term not in self.inverted_idx:\\n self.inverted_idx[term] = 1\\n unique_terms_counter += 1\\n else:\\n self.inverted_idx[term] += 1\\n if term not in self.posting_dict:\\n self.posting_dict[term] = []\\n\\n self.posting_dict[term].append(\\n (document.tweet_id, document_dictionary[term])) # key: str , value: array of tuples\\n\\n max_tf = max(document_dictionary[term], max_tf)\\n\\n except:\\n\\n print('problem with the following key {}'.format(term[0]))\\n\\n document.max_tf = max_tf\\n document.unique_terms = unique_terms_counter\\n self.docs_count += 1\\n\\n modulo = int(document.tweet_id) % 10\\n self.documents[modulo][document.tweet_id] = [document.term_doc_dictionary, document.max_tf]\\n\\n if self.docs_count == self.DOCS_SIZE or end_of_corpus: # if we reach chunk size or end of corpus\\n self.add_to_file(end_of_corpus)\\n self.docs_count = 0\\n self.posting_dict = {}\\n\\n for i in self.documents: # 0 - 9\\n if self.documents[i].__len__() > 15000:\\n doc = utils.load_obj(self.out + \\\"document\\\" + str(i))\\n doc.update(self.documents[i])\\n utils.save_obj(doc, self.out + \\\"document\\\" + str(i))\\n self.documents[i] = {}\",\n \"def upload(self, documents: List[Document], vectorise_func) -> None:\\n\\n # Add doc_store to documents\\n for d in documents:\\n d.doc_store = self\\n # Check ID uniqueness\\n check_duplicate_documents(documents)\\n # Check type consistency\\n check_document_types(documents)\\n # Batching\\n batches = batch_items(documents)\\n\\n # Update document class conveniently\\n if issubclass(type(documents[0]), ChunkedDocument):\\n self._doc_class = ChunkedDocument\\n\\n for batch in batches:\\n vectorise_func(batch, self)\\n self.documents += batch\",\n \"def add_doc(self, document):\\n # Split document up into list of strings\\n #words = self.tokenize(document)\\n words = document\\n # Count word frequencies in this document\\n word_counts = {}\\n for word in words:\\n word_counts[word] = word_counts.get(word, 0) + 1\\n # Add word counts as new row to sparse matrix\\n self.sparse.append(word_counts)\\n # Add to total document count for each word\\n for word in word_counts:\\n self.doc_count[word] = self.doc_count.get(word, 0) + 1\",\n \"def _apply_mapping(self, document, mapping):\\n if not mapping:\\n return document\\n new_document = {v: document[k] for k, v in mapping.items() if k in document}\\n # Keep track of missing keys\\n self.missing_keys.update([k for k in mapping if k not in document])\\n\\n # Document errors for missing documents\\n if not new_document:\\n self.failed += 1\\n self.failed_ids.append(\\n document.get(\\\"id\\\", document.get(\\\"ID\\\", document.get(\\\"_id\\\", None)))\\n )\\n return new_document\",\n \"def _merge_conllu_subtokens(self, lines: List[str], doc: Doc)-> Doc:\\n # identify and process all subtoken spans to prepare attrs for merging\\n subtok_spans = []\\n for line in lines:\\n parts = line.split(\\\"\\\\t\\\")\\n id_, word, lemma, pos, tag, morph, head, dep, _1, misc = parts\\n if \\\"-\\\" in id_:\\n subtok_start, subtok_end = id_.split(\\\"-\\\")\\n subtok_span = doc[int(subtok_start) - 1 : int(subtok_end)]\\n subtok_spans.append(subtok_span)\\n # create merged tag, morph, and lemma values\\n tags = []\\n morphs = {}\\n lemmas = []\\n for token in subtok_span:\\n tags.append(token.tag_)\\n lemmas.append(token.lemma_)\\n if token._.merged_morph:\\n for feature in token._.merged_morph.split(\\\"|\\\"):\\n field, values = feature.split(\\\"=\\\", 1)\\n if field not in morphs:\\n morphs[field] = set()\\n for value in values.split(\\\",\\\"):\\n morphs[field].add(value)\\n # create merged features for each morph field\\n for field, values in morphs.items():\\n morphs[field] = field + \\\"=\\\" + \\\",\\\".join(sorted(values))\\n # set the same attrs on all subtok tokens so that whatever head the\\n # retokenizer chooses, the final attrs are available on that token\\n for token in subtok_span:\\n token._.merged_orth = token.orth_\\n token._.merged_lemma = \\\" \\\".join(lemmas)\\n token.tag_ = \\\"_\\\".join(tags)\\n token._.merged_morph = \\\"|\\\".join(sorted(morphs.values()))\\n token._.merged_spaceafter = (\\n True if subtok_span[-1].whitespace_ else False\\n )\\n\\n with doc.retokenize() as retokenizer:\\n for span in subtok_spans:\\n retokenizer.merge(span)\\n\\n return doc\",\n \"def count_doc_frequencies(self, docs):\\n frequencyIndex = {}\\n doc_id = 0\\n for doc in docs:\\n for term in doc:\\n if term not in frequencyIndex:\\n frequencyIndex[term] = [doc_id]\\n else:\\n for id in frequencyIndex[term]:\\n if doc_id == id:\\n break\\n else:\\n frequencyIndex[term].append(doc_id)\\n doc_id+=1\\n\\n for term in frequencyIndex:\\n occurences = len(frequencyIndex[term])\\n frequencyIndex[term] = occurences\\n\\n return frequencyIndex\",\n \"def set_documents(cls, input_list_text: List[str]) -> None:\\n cls.documents = input_list_text\",\n \"def featurize(movies):\\n ###TODO \\n movies['features'] = \\\"\\\" \\n get_h = set() \\n vocab_dict = {}\\n df_dict_return = {}\\n tup_list = []\\n index_dict = {}\\n index_dict_1 = {}\\n movie_len = len(movies) \\n #print(\\\"MovieLength::\\\",movie_len)\\n #print(\\\"MOVIES:::\\\",movies)\\n \\n get_h = cal_unique_features(movies) # num_features\\n\\n vocab_dict = cal_unique_vocab(get_h) # vocab complete\\n\\n len_vocab = len(get_h)\\n \\n df_dict_return = cal_unique_docs(get_h,movies) # df(i)\\n\\n for token in get_h :\\n #tup_list.clear()\\n #print(\\\"token_GOTTTTT:::\\\",token)\\n for index,row in movies.iterrows(): \\n #print(\\\"row_got::\\\",row)\\n gen_list = row['tokens']\\n #print(\\\"gen_list::\\\",gen_list)\\n #mov_id = row['movieId'] \\n #print(\\\"mov_id::\\\",mov_id)\\n token_count_1 = Counter(gen_list).most_common()[:1]\\n tok = token_count_1[0]\\n index_dict_1[index] = tok[1]\\n token_count = gen_list.count(token)\\n #print(\\\"token_count::\\\",token_count)\\n tup = (index,token_count)\\n #print(\\\"tuple::\\\",tup)\\n tup_list.append(tup)\\n #print(\\\"LIST_PRINT:::::::::::::\\\",tup_list)\\n index_dict[token] = tup_list\\n tup_list = []\\n \\n \\n #print(\\\"INDEX_DICT:::\\\",index_dict) # tf(i,d)\\n #print(\\\"INDEX_DICT_1:::\\\",index_dict_1) # max_k dict per docx\\n \\n \\n for ind, row in movies.iterrows():\\n data_list = []\\n rows_list = []\\n columns_list = []\\n gen_list = row['tokens']\\n #print(\\\"TOKENS GOTTT::\\\",gen_list) \\n for gen in gen_list:\\n tf = get_tf_value(index_dict,gen,ind)\\n #print(\\\"TF GOTTT::\\\",tf) \\n tf_weight = float( tf / index_dict_1[ind])\\n #print(\\\"tf_weight::\\\",tf_weight)\\n df_weight = float( math.log10( movie_len / df_dict_return[gen] ) )\\n #print(\\\"df_weight::\\\",df_weight)\\n final_tfidf = tf_weight * df_weight\\n #print(\\\"final_tfidf::\\\",final_tfidf)\\n data_list.append(final_tfidf)\\n columns_list.append(vocab_dict[gen])\\n rows_list.append(0) \\n csr = csr_matrix((data_list, (rows_list,columns_list)), shape=(1,len_vocab))\\n #print(\\\"TYPE of CSR GOTT::\\\",type(csr))\\n #print(\\\"CSR GOTT:::\\\",csr) \\n movies.set_value(ind, 'features', csr)\\n \\n #print(\\\"UPDATE movies::\\\",movies) \\n\\n return(movies,vocab_dict)\\n \\n\\n pass\",\n \"def index_terms(self):\\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\\n self.doc_store.dict.iteritems()]\",\n \"def updateWordCounts():\\n emaildata = loadEmailData()\\n englishwords = importDictionary()\\n countAllWords(emaildata, englishwords)\",\n \"def set_document_numbers(notices):\\n\\n if len(notices) > 1:\\n for notice in notices:\\n notice['document_number'] = split_doc_num(\\n notice['document_number'], notice['effective_on'])\\n return notices\",\n \"def set_document_numbers(notices):\\n\\n if len(notices) > 1:\\n for notice in notices:\\n notice['document_number'] = split_doc_num(\\n notice['document_number'], notice['effective_on'])\\n return notices\",\n \"def update(self, docs: DocumentArray, *args, **kwargs):\\n cursor = self.connection.cursor()\\n psycopg2.extras.execute_batch(\\n cursor,\\n f'UPDATE {self.table} SET DOC = %s WHERE ID = %s',\\n [\\n (\\n doc.SerializeToString(),\\n doc.id,\\n )\\n for doc in docs\\n ],\\n )\\n self.connection.commit()\",\n \"def add_documents(self, docs):\\n for doc in docs:\\n assert isinstance(doc, pylastica.document.Document), \\\"All items in list docs must be of type Document: %r\\\" % doc\\n doc.doc_type = self.name\\n return self.index.add_documents(docs)\",\n \"def updateWordList(emailids):\\n with open('res/dictionary.txt', 'r') as f:\\n lines = f.readlines()\\n words = set([line.strip() for line in lines])\\n\\n with open('res/dictionary.txt', 'a') as f:\\n for emailid in emailids: \\n email = e.Email(emailid)\\n subject = set(email.parsedsubject)\\n body = set(email.body)\\n try:\\n emailcontent = body.union(subject)\\n for word in emailcontent:\\n if not word in words:\\n words.add(word)\\n f.write(word + '\\\\n')\\n except AttributeError:\\n print(body)\",\n \"def update_documents(self, engine_name, documents):\\n endpoint = \\\"engines/{}/documents\\\".format(engine_name)\\n data = json.dumps(documents)\\n\\n return self.swiftype_session.request('patch', endpoint, data=data)\",\n \"def create_freq_dict(corpus, doc_info):\\n for idx, content in enumerate(corpus):\\n word_freq_table = {}\\n splitted_sentence = content.split()\\n for word in splitted_sentence:\\n word = word.lower()\\n if word not in word_freq_table:\\n word_freq_table[word] = 1\\n else:\\n word_freq_table[word] += 1\\n doc_info[idx]['freq_dict'] = word_freq_table\",\n \"def index_feats_dict(self):\\n doc_features_dict = {}\\n\\n for index, doc in zip(self.index, self.series):\\n # Sets for a doc and feature words\\n doc_set = set(doc.split())\\n feat_set = set(self.features)\\n\\n # Shared words between the two sets\\n interset_words = doc_set.intersection(feat_set)\\n\\n # Append to doc_features_dict\\n doc_features_dict[index] = list(interset_words)\\n\\n return doc_features_dict\",\n \"def pos():\\n pos_list = []\\n for token in doc:\\n pos_list.append(token.pos_)\\n setList = list(set(pos_list))\\n my_dict = {i: pos_list.count(i) for i in setList}\\n print(my_dict)\",\n \"def finish_documents():\\n\\n doc_ids = json.loads(request.form['doc_ids'])\\n\\n for docid in doc_ids:\\n\\n document = Document.query.filter_by(id=docid).first_or_404()\\n\\n document.status = \\\"OK\\\"\\n\\n db.session.add(document)\\n\\n db.session.commit()\",\n \"def test_update_list(self):\\n u = stellr.UpdateCommand(TEST_HTTP)\\n docs = [{'a': 1}, {'b': 2}]\\n u.add_documents(docs)\\n self.assertEqual(2, len(u._commands))\\n self.assertEqual(u.body,\\n ('{\\\"add\\\": {\\\"doc\\\": {\\\"a\\\": 1}}'\\n ',\\\"add\\\": {\\\"doc\\\": {\\\"b\\\": 2}}}'))\",\n \"def add_documents(self, documents):\\n\\t\\t\\n\\t\\t# flag for StopIteration exceptions\\n\\t\\tmore_documents = True\\n\\t\\t# loop while there are still documents in the iterator\\n\\t\\twhile more_documents:\\n\\t\\t\\t# increment batch number\\n\\t\\t\\tbatch = len(self.batch_stats) + 1\\n\\t\\t\\t# count sentences\\n\\t\\t\\tsentences_count = 0\\n\\t\\t\\t# create temporary batch data file in the version directory\\n\\t\\t\\tbatch_file = os.path.join(self.file_base.get_version_path(self.version), \\\"data.jl.gz.temp\\\")\\n\\t\\t\\t# try to read the next batch of files, catch exception and stop if there are no more\\n\\t\\t\\ttry:\\n\\t\\t\\t\\t# get next document before opening the file just to make sure it's there\\n\\t\\t\\t\\tdocument = documents.next()\\n\\t\\t\\t\\t# open the data file\\n\\t\\t\\t\\twith gzip.open(batch_file, \\\"wb\\\") as outfile:\\n\\t\\t\\t\\t\\t# loop through DOCUMENT_BATCH_SIZE documents\\n\\t\\t\\t\\t\\tfor i in range(DocumentDatabase.DOCUMENT_BATCH_SIZE):\\n\\t\\t\\t\\t\\t\\t# count sentences in document\\n\\t\\t\\t\\t\\t\\tfor paragraph in document[\\\"paragraphs\\\"]:\\n\\t\\t\\t\\t\\t\\t\\tsentences_count += len(paragraph[\\\"sentences\\\"])\\n\\t\\t\\t\\t\\t\\t# write JSON to file one line at a time\\n\\t\\t\\t\\t\\t\\toutfile.write(\\\"%s\\\\n\\\" % json.dumps(document))\\n\\t\\t\\t\\t\\t\\t# if we are not done with this batch, retrieve the next document\\n\\t\\t\\t\\t\\t\\tif i < DocumentDatabase.DOCUMENT_BATCH_SIZE - 1:\\n\\t\\t\\t\\t\\t\\t\\tdocument = documents.next()\\n\\t\\t\\texcept StopIteration:\\n\\t\\t\\t\\t# the end of the documents stream, set the flag to False\\n\\t\\t\\t\\tmore_documents = False\\n\\t\\t\\t# make sure the batch isn't empty\\n\\t\\t\\tif sentences_count > 0:\\n\\t\\t\\t\\t# create the new batch in the file system\\n\\t\\t\\t\\tself.version_batches.create_latest_version()\\n\\t\\t\\t\\t# add the stats to the statistics hash\\n\\t\\t\\t\\tself.batch_stats[batch] = BatchStats(sentences_count)\\n\\t\\t\\t\\t# write the batch statistics to file\\n\\t\\t\\t\\twith codecs.open(self._get_batch_stat_file(batch), \\\"wb\\\", \\\"utf-8\\\") as outfile:\\n\\t\\t\\t\\t\\t# write the JSON representation for the stats\\n\\t\\t\\t\\t\\toutfile.write(json.dumps(self.batch_stats[batch].to_json()))\\n\\t\\t\\t\\t# move the temp data file to the correct location inside the version folder\\n\\t\\t\\t\\tos.rename(batch_file, self._get_batch_file(batch))\",\n \"def get_preprocessed_docs(formatted_docs):\\r\\n preprocessed_docs = {}\\r\\n for idx in formatted_docs.keys():\\r\\n preprocessed_docs[idx] = preprocess(formatted_docs[idx])\\r\\n return preprocessed_docs\",\n \"def load_flattened_documents(data_dir: str, docids: Set[str]) -> Dict[str, List[str]]:\\n unflattened_docs = load_documents(data_dir, docids)\\n flattened_docs = dict()\\n for doc, unflattened in unflattened_docs.items():\\n flattened_docs[doc] = list(chain.from_iterable(unflattened))\\n return flattened_docs\",\n \"def build(self,documents):\\n\\t\\tself.vectorKeywordIndex = self.getVectorKeywordIndex(documents)\\n\\n\\t\\tself.documentVectors = [self.createVector(document) for document in documents]\",\n \"def _build_token_dict(self, corpus: List[List[str]], min_count: int = 3):\\n token2idx = {\\n self.token_pad: 0,\\n self.token_unk: 1,\\n self.token_bos: 2,\\n self.token_eos: 3\\n }\\n\\n token2count = {}\\n for sentence in corpus:\\n for token in sentence:\\n count = token2count.get(token, 0)\\n token2count[token] = count + 1\\n\\n # 按照词频降序排序\\n sorted_token2count = sorted(token2count.items(),\\n key=operator.itemgetter(1),\\n reverse=True)\\n token2count = collections.OrderedDict(sorted_token2count)\\n\\n for token, token_count in token2count.items():\\n if token not in token2idx and token_count >= min_count:\\n token2idx[token] = len(token2idx)\\n\\n self.token2idx = token2idx\\n self.idx2token = dict([(value, key)\\n for key, value in self.token2idx.items()])\\n logging.debug(f\\\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\\\")\\n self.dataset_info['token_count'] = len(self.token2idx)\",\n \"def update_words(data, book_num):\\n\\tglobal word_count\\n\\t#find count of each word in the book and update the dictionary\\n\\tfor words in data:\\n\\t\\tword_count[words][book_num] = (word_count.get(words,0)[book_num] + 1)\\n\\t#print(word_count)\",\n \"def generate_dict(self):\\n dict = defaultdict(list)\\n for i in range(self.no_of_docs-1):\\n doc_txt = self.doc_to_df(i)\\n #assign key to index in dictionary and its locations as tuples(docid,line,wordpos) as the values\\n for j in range(len(doc_txt)):\\n for k in range(doc_txt.shape[1]):\\n key = doc_txt[k][j]\\n dict[key].append((i,j,k))\",\n \"def parse_doc(self, doc_as_list):\\n tweet_id = doc_as_list[0]\\n tweet_date = doc_as_list[1]\\n full_text = doc_as_list[2]\\n url = doc_as_list[3]\\n retweet_text = doc_as_list[4]\\n retweet_url = doc_as_list[5]\\n quote_text = doc_as_list[6]\\n quote_url = doc_as_list[7]\\n term_dict = {}\\n tokenized_text = self.parse_sentence(full_text)\\n doc_length = len(tokenized_text) # after text operations.\\n\\n for i, term in enumerate(tokenized_text):\\n if term not in term_dict.keys():\\n term_dict[term] = [1, [i]]\\n else:\\n term_dict[term][0] += 1\\n term_dict[term][1].append(i)\\n\\n document = Document(tweet_id, tweet_date, full_text, url, retweet_text, retweet_url, quote_text,\\n quote_url, term_dict, doc_length)\\n return document\",\n \"def set(self, doc, fields_values):\\n fields_values = Object.from_bson(fields_values)\\n for k,v in fields_values.items():\\n self._set(doc, k.split('.'), v)\\n impl = self._impl(doc)\\n return impl.update({'_id':doc._id}, {'$set':fields_values})\",\n \"def extract(self, documents):\\n\\n # Feature vector to return\\n features = np.zeros((len(documents), len(self.idx_to_word)))\\n\\n # Raise an exception if 'extract' is called before 'preprocess'\\n if len(self.word_to_idx) == 0 or len(self.idx_to_word) == 0:\\n raise Exception(\\\"Dictionary not initialised.\\\")\\n\\n # Iterate over all documents\\n for idx, doc in enumerate(documents):\\n # Split the doc into a list of words\\n words = extract_words(doc)\\n\\n # For each word\\n for w in words:\\n # Calculate it's frequency, however, keep in mind\\n # that this word may not have been in the training\\n # corpus. In that case, ignore the word.\\n ''' YOUR CODE HERE '''\\n try:\\n features[idx][self.word_to_idx[w]] = words.count(w)\\n except KeyError:\\n pass\\n\\n ''' END CODE FOR THIS LOOP '''\\n\\n # Divide the vector by the total number of words in the document to\\n # normalize the frequencies.\\n ''' YOUR CODE HERE '''\\n features[idx] = features[idx]/len(words)\\n ''' END CODE FOR THIS LOOP '''\\n\\n return features\",\n \"def _vector_mapping(self) -> dict:\\n words = set()\\n for file in os.listdir(self.processed_path):\\n doc_path = f\\\"{self.processed_path}/{file}\\\"\\n with open(doc_path, 'r') as f:\\n text_words = f.readline().split()\\n words = words.union(set(text_words))\\n words = list(words)\\n words.sort()\\n\\n return dict(zip(words, range(len(words))))\",\n \"def add(self, token_docid):\\n token = token_docid[0]\\n doc_id = token_docid[1]\\n # collapse identical tokens together\\n if token in self.posting:\\n self.posting[token].append(doc_id)\\n else:\\n self.posting[token] = [doc_id]\",\n \"def __call__(self, doc: Doc) -> Doc:\\n for val in self._get_vals(doc):\\n key = self._get_key(val)\\n try:\\n self._table.get(key).append(val)\\n except AttributeError:\\n self._table.set(key, [val])\\n self._size += 1\\n return super().__call__(doc)\",\n \"def __parse_corpus(self, corpus):\\n corpus = self.__handle_corpus_unkwon_words(corpus)\\n start_token = ' '.join([NGramModel.START_SENTENCE_TOKEN]*(self.__n-1))\\n word_list = corpus.replace(NGramModel.START_SENTENCE_TOKEN, start_token).split()\\n \\n for n in range(1, self.__n+1): \\n self.__ngram_counts[n] = {}\\n for ngram, count in Counter(self.__generate_n_grams(word_list, n)).items():\\n self.__ngram_counts[n][' '.join(ngram)] = count\",\n \"def documents(self, **kw):\\r\\n \\r\\n doc_reader = self.doc_reader\\r\\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))\",\n \"def merge_all_claims_norm_dicts_for_docs(): \\n# docs_norm_scores_dicts_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\"\\n docs_norm_scores_dicts_path = linux_base_path+\\\"/docs_norm_scores_dicts\\\"\\n# all_claims_norms_scores_merged_dict = base_path +\\\"\\\\\\\\all_claims_norms_scores_merged_dict\\\"\\n all_claims_norms_scores_merged_dict = linux_base_path +\\\"/all_claims_norms_scores_merged_dict\\\"\\n for alpha in range(0,11,1):\\n for beta in range(0,10,1):\\n docs_scores_all_claims = {}\\n for filename in os.listdir(docs_norm_scores_dicts_path):\\n (alpha_f,beta_f)=turn_to_float([alpha,beta])\\n if \\\"_alpha_\\\"+str(alpha_f)+\\\"_\\\" in filename and \\\"_beta_\\\"+str(beta_f)+\\\"_\\\" in filename:\\n curr_dict = read_pickle(docs_norm_scores_dicts_path+\\\"/\\\"+filename)\\n docs_scores_all_claims = dict(docs_scores_all_claims.items() + curr_dict.items()) #merge dicts\\n save_pickle(all_claims_norms_scores_merged_dict+\\\"/docs_norm_scores_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f),docs_scores_all_claims)\",\n \"def tokenize_replace_pos(doc_list, language_code, replace_pos,\\n core_num=multiprocessing.cpu_count()):\\n param = [[d, language_code, replace_pos] for d in doc_list]\\n pool = multiprocessing.Pool(core_num)\\n return pool.map(_tokenize_replace_pos4map, param)\",\n \"def refine_tokens( self, tokens ):\\n k = 1.75\\n b = 0.75\\n stop_words_file = \\\"stop_words.txt\\\"\\n all_stopwords = list()\\n refined_tokens_sources = dict()\\n \\n # collect all the stopwords\\n with open( stop_words_file ) as file:\\n lines = file.read()\\n all_stopwords = lines.split( \\\"\\\\n\\\" )\\n \\n for source in tokens:\\n refined_tokens = dict()\\n files = dict()\\n inverted_frequency = dict()\\n file_id = -1\\n total_file_length = 0\\n for item in tokens[ source ]:\\n file_id += 1\\n file_tokens = tokens[ source ][ item ].split(\\\" \\\")\\n if source in \\\"name_desc_edam_help\\\":\\n file_tokens = utils._clean_tokens( file_tokens, all_stopwords )\\n total_file_length += len( file_tokens )\\n term_frequency = dict()\\n for token in file_tokens:\\n if token is not '':\\n file_ids = list()\\n if token not in inverted_frequency:\\n file_ids.append( file_id )\\n else:\\n file_ids = inverted_frequency[ token ]\\n if file_id not in file_ids:\\n file_ids.append( file_id )\\n inverted_frequency[ token ] = file_ids\\n # for term frequency\\n if token not in term_frequency:\\n term_frequency[ token ] = 1\\n else:\\n term_frequency[ token ] += 1\\n files[ item ] = term_frequency\\n N = len( files )\\n average_file_length = float( total_file_length ) / N\\n # find BM25 score for each token of each tool. It helps to determine\\n # how important each word is with respect to the tool and other tools\\n for item in files:\\n file_item = files[ item ]\\n file_length = len( file_item )\\n for token in file_item:\\n tf = file_item[ token ]\\n # normalize the term freq of token for each document\\n tf = float( tf ) / file_length\\n idf = np.log2( N / len( inverted_frequency[ token ] ) )\\n alpha = ( 1 - b ) + ( float( b * file_length ) / average_file_length )\\n tf_star = tf * float( ( k + 1 ) ) / ( k * alpha + tf )\\n tf_idf = tf_star * idf\\n file_item[ token ] = tf_idf\\n # filter tokens based on the BM25 scores and stop words. Not all tokens are important\\n for item in files:\\n file_tokens = files[ item ]\\n tokens_scores = [ ( token, score ) for ( token, score ) in file_tokens.items() ]\\n sorted_tokens = sorted( tokens_scores, key=operator.itemgetter( 1 ), reverse=True )\\n refined_tokens[ item ] = sorted_tokens\\n tokens_file_name = 'tokens_' + source + '.txt'\\n token_file_path = os.path.join( os.path.dirname( self.tools_data_path ) + '/' + tokens_file_name )\\n with open( token_file_path, 'w' ) as file:\\n file.write( json.dumps( refined_tokens ) )\\n file.close()\\n refined_tokens_sources[ source ] = refined_tokens\\n return refined_tokens_sources\",\n \"def build_ngram_index(tokenized_documents, ngrams):\\n dictionary = {}\\n\\n doc_ngrams = {}\\n for doc in tokenized_documents:\\n ngrams_freq = {}\\n\\n measures = nltk.collocations.BigramAssocMeasures()\\n finder = BigramCollocationFinder.from_words(tokenized_documents[doc])\\n freqs = finder.ngram_fd\\n for ngram in freqs:\\n ngrams_freq[ngram] = freqs[ngram]\\n \\n measures = nltk.collocations.TrigramAssocMeasures()\\n finder = TrigramCollocationFinder.from_words(tokenized_documents[doc])\\n freqs = finder.ngram_fd\\n for ngram in freqs:\\n ngrams_freq[ngram] = freqs[ngram]\\n\\n doc_ngrams[doc] = ngrams_freq\\n\\n for ngram in ngrams:\\n dictionary[ngram] = [0]\\n for doc in doc_ngrams:\\n if ngram in doc_ngrams[doc]:\\n dictionary[ngram][0] += doc_ngrams[doc][ngram]\\n dictionary[ngram].append((doc, doc_ngrams[doc][ngram]))\\n \\n return dictionary\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68998206","0.67045903","0.63965476","0.6270014","0.6202376","0.61885744","0.6151995","0.60434496","0.60377157","0.59981596","0.59295934","0.58968425","0.5878697","0.5846581","0.5829846","0.57702076","0.57415456","0.5731184","0.571159","0.56422395","0.56206626","0.56158304","0.56098443","0.5605549","0.56044024","0.5601467","0.5599388","0.5561202","0.5560279","0.55516464","0.5550332","0.5547204","0.5522102","0.55220526","0.5517955","0.5516518","0.5508086","0.5503605","0.5489143","0.54866636","0.54812765","0.54798603","0.546946","0.5467494","0.5464095","0.546391","0.54616797","0.5448641","0.544098","0.54241973","0.54238206","0.5410954","0.5390047","0.5376325","0.53683513","0.5364197","0.5351491","0.53480136","0.5343806","0.534199","0.53341246","0.53310096","0.53275794","0.5322643","0.5319898","0.5317479","0.52941674","0.52871186","0.5282909","0.52801293","0.52791196","0.52791196","0.5277453","0.5261558","0.52605224","0.52593344","0.5257611","0.5256494","0.52483225","0.5246229","0.52368593","0.5230774","0.52286446","0.5224301","0.522175","0.52179825","0.52160466","0.5212943","0.521123","0.5209256","0.52077514","0.52023995","0.5199851","0.51880676","0.5183054","0.5163004","0.51602674","0.51461196","0.5139358","0.5132946"],"string":"[\n \"0.68998206\",\n \"0.67045903\",\n \"0.63965476\",\n \"0.6270014\",\n \"0.6202376\",\n \"0.61885744\",\n \"0.6151995\",\n \"0.60434496\",\n \"0.60377157\",\n \"0.59981596\",\n \"0.59295934\",\n \"0.58968425\",\n \"0.5878697\",\n \"0.5846581\",\n \"0.5829846\",\n \"0.57702076\",\n \"0.57415456\",\n \"0.5731184\",\n \"0.571159\",\n \"0.56422395\",\n \"0.56206626\",\n \"0.56158304\",\n \"0.56098443\",\n \"0.5605549\",\n \"0.56044024\",\n \"0.5601467\",\n \"0.5599388\",\n \"0.5561202\",\n \"0.5560279\",\n \"0.55516464\",\n \"0.5550332\",\n \"0.5547204\",\n \"0.5522102\",\n \"0.55220526\",\n \"0.5517955\",\n \"0.5516518\",\n \"0.5508086\",\n \"0.5503605\",\n \"0.5489143\",\n \"0.54866636\",\n \"0.54812765\",\n \"0.54798603\",\n \"0.546946\",\n \"0.5467494\",\n \"0.5464095\",\n \"0.546391\",\n \"0.54616797\",\n \"0.5448641\",\n \"0.544098\",\n \"0.54241973\",\n \"0.54238206\",\n \"0.5410954\",\n \"0.5390047\",\n \"0.5376325\",\n \"0.53683513\",\n \"0.5364197\",\n \"0.5351491\",\n \"0.53480136\",\n \"0.5343806\",\n \"0.534199\",\n \"0.53341246\",\n \"0.53310096\",\n \"0.53275794\",\n \"0.5322643\",\n \"0.5319898\",\n \"0.5317479\",\n \"0.52941674\",\n \"0.52871186\",\n \"0.5282909\",\n \"0.52801293\",\n \"0.52791196\",\n \"0.52791196\",\n \"0.5277453\",\n \"0.5261558\",\n \"0.52605224\",\n \"0.52593344\",\n \"0.5257611\",\n \"0.5256494\",\n \"0.52483225\",\n \"0.5246229\",\n \"0.52368593\",\n \"0.5230774\",\n \"0.52286446\",\n \"0.5224301\",\n \"0.522175\",\n \"0.52179825\",\n \"0.52160466\",\n \"0.5212943\",\n \"0.521123\",\n \"0.5209256\",\n \"0.52077514\",\n \"0.52023995\",\n \"0.5199851\",\n \"0.51880676\",\n \"0.5183054\",\n \"0.5163004\",\n \"0.51602674\",\n \"0.51461196\",\n \"0.5139358\",\n \"0.5132946\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6872754"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":7384,"cells":{"query":{"kind":"string","value":"Get the list of token_id given doc."},"document":{"kind":"string","value":"def doc2id(self, doc):\n if isinstance(doc, string_types):\n raise TypeError(\"doc2idx expects an array of unicode tokens on input, not a single string\")\n doc = map(self.process_token, doc)\n return [self.token_to_id(token) for token in doc]"},"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 doc2id(self, doc):\n doc = map(self.process_token, doc)\n return [self.token_to_id(token) for token in doc]","def get_tokens(self, document):\n raise NotImplementedError()","def doc2token(self, doc):\n return [self.word2idx[word] if self.word2idx.__contains__(word)\n else self.word2idx['UNK'] for word in doc]","def get_doc_ids(self):\n cursor = self.connection.cursor()\n cursor.execute(\"SELECT id FROM documents\")\n results = [r[0] for r in cursor.fetchall()]\n cursor.close()\n return results","def get_doc_ids(self):\n cursor = self.connection.cursor()\n cursor.execute(\"SELECT id FROM documents\")\n results = [r[0] for r in cursor.fetchall()]\n cursor.close()\n return results","def id2doc(self, ids):\n return [self.id_to_token(idx) for idx in ids]","def id2doc(self, ids):\n return [self.id_to_token(idx) for idx in ids]","def get_ids(self) -> List[str]:","def tokens(self):\n return self.rpc.call(MsfRpcMethod.AuthTokenList)['tokens']","def keys(self):\n return list(self.token2id.values())","def get_ids(self,tokens, tokenizer, max_seq_length):\n token_ids = tokenizer.convert_tokens_to_ids(tokens,)\n input_ids = token_ids + [0] * (max_seq_length-len(token_ids))\n return input_ids","def convert_ids_to_tokens(self, tok_ids):\n result = []\n for tok in tok_ids:\n word = self.itos(tok)\n result.append(word)\n return result","def tok2idx_data(token2id, tok_data):\n idx_data = []\n for toks in tok_data:\n idx_lst = [\n token2id[tok] if tok in token2id else UNK_IDX for tok in toks]\n idx_data.append(idx_lst)\n return idx_data","def convert_tokens_to_ids(self, tokens):\n ids = []\n for token in tokens:\n ids.append(self.vocab[token])\n if len(ids) > self.max_len:\n logger.warning('Token indices sequence length is longer than the specified maximum sequence length for this BERT model ({} > {}). Running this sequence through BERT will result in indexing errors'.format(len(ids), self.max_len))\n return ids","def list_ids(token):\n\n init_tenant_context(token, db)\n\n data = []\n LOGGER.debug(f\" Fetching list with known devices\")\n for id in db.session.query(Device.id).all():\n data.append(id[0])\n return data","def extarct_id_tf(docs):\n\n if len(docs) == 0:\n return []\n docs = docs.split(',')\n ret = []\n for doc in docs:\n doc = doc.split('|')\n # doc_id, tf\n ret.append((int(doc[0]), int(doc[1])))\n return ret","def list_tokens(user):\n return AppSpecificAuthToken.select().where(AppSpecificAuthToken.user == user)","def list(uid: int):\n\n return Token.list(uid)","def convert_tokens_to_ids(self, tokens):\n ids = []\n if isinstance(tokens, str):\n if tokens in self.special_tokens:\n return self.special_tokens[tokens]\n else:\n return self.encoder.get(tokens, self.unk_id)\n for token in tokens:\n if token in self.special_tokens:\n ids.append(self.special_tokens[token])\n else:\n ids.append(self.encoder.get(token, self.unk_id))\n return ids","def get_ids(self, text):\n\n tokens = [token.orth for token in self.tokenizer(text)]\n ids = []\n for token in tokens:\n try:\n id = self.vocab.vectors.key2row[token]\n except KeyError:\n id = self.oov_id\n\n ids.append(id)\n\n return ids","def get_tokens(self) -> List[str]:\n return self.tokens","def getReviewsWithToken(self, token):\n\n wordid = self.find_word_in_dictionary(token)\n # word is not in the dictionary\n if wordid == -1:\n print(\"Token is not in the dictionary\")\n return 0\n\n with open(self.doc_to_words_path, 'rb') as bin:\n tup = []\n while bin.tell() != os.fstat(bin.fileno()).st_size:\n # get wordid:\n docid_in_file = int.from_bytes(bin.read(4), 'big')\n # get frequency:\n frequency = int.from_bytes(bin.read(4), 'big')\n # count words:\n count = 0\n for i in range(frequency):\n wordid_in_file = int.from_bytes(bin.read(4), 'big')\n if wordid == wordid_in_file:\n count += 1\n tup.append(docid_in_file)\n tup.append(count)\n return tuple(tup)","def decode_ids_to_tokens(self, tokens: List[int]) -> List[str]:\n token_list = self.tokenizer.ids_to_tokens(tokens)\n return token_list","def _get_vocab_id_list(self, json_obj):\n return json_obj","def get_ids(self, text):\n\n tokens = [token.orth for token in self.tokenizer(text)]\n ids = []\n for token in tokens:\n try:\n id = self._vocab.vectors.key2row[token]\n except KeyError:\n id = self.oov_id\n\n ids.append(id)\n\n return ids","def get_document_tags(self, docid):\n return [(key, json.loads(value))\n for key, value\n in self.sql_session.query(Feature)\n .filter(Feature.document == docid)\n .values(Feature.key, Feature.value)]","def get_token_list():\n token_list = []\n tokens_dir_path = os.path.join(BASE_DIR, TOKENS_DIR)\n for dir, dirs, files in os.walk(tokens_dir_path):\n for file_name in files:\n file = open(os.path.join(tokens_dir_path, file_name), 'r')\n token_list.append(file.read().strip())\n file.close()\n return token_list","def convert_ids_to_tokens(self, ids):\n tokens = []\n for i in ids:\n tokens.append(self.ids_to_tokens[i])\n return tokens","def _get_doc_ids(dir_id, docname):\n cur = conn.cursor(cursor_factory=pgx.RealDictCursor)\n querystring = ('select id, source_docid, target_docid from {} where dir_id = %s and docname = %s;'\n result = execute_query(querystring.format(TABLES[3])), (dir_id, docname))\n if result:\n return result['id'], result['source_docid'], result['target_docid']\n return None, None, None","def get_extent_token_ids(self, **kwargs):\n token_span = self.get_extent_tokens(**kwargs)\n return [t.index for t in token_span]","def docs2ids(self):\n self.docs = [ [self.vocab[word] for word in doc] for doc in self.docs]","def get_doc_id_titles(self):\n cursor = self.connection.cursor()\n cursor.execute(\"SELECT id, title FROM documents\")\n results = [(r[0], r[1]) for r in cursor.fetchall()]\n cursor.close()\n return results","def tokenize(doc):\n\n # Calls NLTK function to tokenize the document. Broken into individual words, cleans out punctuation\n tokens = nltk.word_tokenize(doc)\n\n return tokens","def get_ids(self, sentence):\n return [self.get_id(word) for word in sentence.strip().split(' ')]","def get_ids(corpus):\n corpusids = []\n for chunk in corpus:\n for _id in chunk.keys():\n corpusids.append(_id)\n return corpusids","def tokens():\n return ['access token', 'refresh token']","def getTokens(self):\n list = []\n for i in range(self.startIdx, self.endIdx + 1):\n token = self.sentence[i]\n list.append(token)\n return list","def get_tokens(self):\r\n return self.token_set","def fetch_doc_tokens(self, document_level, find_query_mixin={}):\n if document_level != 'postwise':\n raise NotImplementedError('document_level:%s' % document_level)\n\n query = {'subreddit':self.subreddit, document_level:{'$exists':True}}\n query.update(find_query_mixin)\n\n for doc in self.posts_read.find(query):\n try:\n yield doc[document_level]['tokens']\n except KeyError:\n # XXX: this shouldn't happen...\n print 'woop, doc missing %s.tokens' % document_level","def get_all_group_ids(token) -> list:\n ids=list()\n _dict = perform_request(app_config.ENDPOINT, token)\n while True:\n for obj in _dict[\"value\"]:\n ids.append(obj[\"id\"])\n if \"@odata.nextLink\" not in _dict:\n return ids\n _dict = perform_request(_dict[\"@odata.nextLink\"], token)","def get_positions(token, docs):\n\n all_matches = [token]\n for doc in docs:\n matches = []\n if token in doc:\n indexes = [i for i, x in enumerate(doc) if x == token]\n matches += [docs.index(doc), len(indexes), indexes]\n if matches:\n all_matches.append(matches)\n return all_matches","def docs(self, searcher, exclude_docs=None):\r\n\r\n try:\r\n return self.matcher(searcher, exclude_docs=exclude_docs).all_ids()\r\n except TermNotFound:\r\n return []","def get_token_list(text):\n return text.split()","def _token_to_id(self, sequence_tokens, token_map, char_map, ngram=0,\n token_ngram_map=None, max_char_sequence_length=-1,\n max_char_length_per_token=-1):\n token_id_list = []\n char_id_list = []\n char_in_token_id_list = []\n ngram_id_list = []\n for token in sequence_tokens:\n char_id = [char_map.get(x, self.VOCAB_UNKNOWN) for x in token]\n char_id_list.extend(char_id[0:max_char_sequence_length])\n char_in_token = [char_map.get(x, self.VOCAB_UNKNOWN)\n for x in token[0:max_char_length_per_token]]\n char_in_token_id_list.append(char_in_token)\n\n token_id_list.append(\n token_map.get(token, token_map[self.VOCAB_UNKNOWN]))\n if ngram > 1:\n for j in range(2, ngram + 1):\n ngram_id_list.extend(\n token_ngram_map[x] for x in\n [\"\".join(sequence_tokens[k:k + j]) for k in\n range(len(sequence_tokens) - j + 1)] if x in\n token_ngram_map)\n if not sequence_tokens:\n token_id_list.append(self.VOCAB_PADDING)\n char_id_list.append(self.VOCAB_PADDING)\n char_in_token_id_list.append([self.VOCAB_PADDING])\n if not ngram_id_list:\n ngram_id_list.append(token_ngram_map[self.VOCAB_PADDING])\n return token_id_list, char_id_list, char_in_token_id_list, ngram_id_list","def queryByDocId(self, docId):\n\n table = self.__getTable()\n return (row['entity'] for row in table.query_2(\n docId__eq = docId,\n index = 'docIdIndex'))","def print_doc_tokens(doc):\n tokens = []\n for token in doc:\n tokens.append([token.text, token.pos_, token.dep_, token.tag_])\n\n df = pd.DataFrame(tokens, columns=[\"text\", \"part-of-speech\", \"syntactic_dependency_relation\", \"tag\"])\n return df","def get_token(self, bot_id):\n res = self.execute(TABELLE['bot']['select']['by_id'], (bot_id,))\n # print(res)\n return res","def tokens(self):\n # type: () -> List[Token]\n return self._tokens","def _list_tokens(self, user_id, tenant_id=None, trust_id=None,\n consumer_id=None):\n raise exception.NotImplemented() # pragma: no cover","def map_tokens_to_ids(self, tokens: List[str], max_length: int = None):\n # truncate extra tokens and pad to `max_length`\n if max_length:\n tokens = tokens[:max_length]\n tokens = tokens + [self._pad_token]*(max_length-len(tokens))\n return [self.map_token_to_id(token) for token in tokens]","def iter_docids(self):\n return iter(self.client.smembers(self.dbprefix + 'docs'))","def _get_token_ids(self, tokens):\n token_ids = self.tokenizer.convert_tokens_to_ids(tokens)\n pad_amount = self.max_seq_length - len(tokens)\n input_ids = token_ids + [0] * pad_amount\n return np.array(input_ids)","def documents(self, **kw):\r\n \r\n doc_reader = self.doc_reader\r\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))","def get_ids_logs(doc):\n\n doc['ids'] = []\n\n with open('/var/log/suricata/eve.json', 'r') as f:\n for line in f:\n #lets go ahead and deserialize the log and pull out sig field\n sig = json.loads(line)['alert']['signature']\n #blergh, too lazy to comment out of suricata, or change UA\n if sig != \"ET POLICY Python-urllib/ Suspicious User Agent\":\n doc['ids'].append(sig)\n\n #add a check for empty ids file and lets just remove the field\n if len(doc['ids']) == 0:\n doc.pop('ids')\n return doc\n\n return doc","def ids(self):\n return (x[\"_id\"] for x in self.document._meta.collection.find(self.spec, fields = (\"_id\",)))","def tokens(self):\n\t\tlabels_and_synonyms = list(itertools.chain.from_iterable(list(self.term_to_tokens.values())))\n\t\ttokens = set(list(itertools.chain.from_iterable([word_tokenize(x) for x in labels_and_synonyms])))\n\t\treturn(list(tokens))","def _tokens_to_terms(self, tokens: Sequence[str]) -> List[int]:\n ret = []\n for t in tokens:\n term = self.stemmer(t)\n if term in self.term2id_dict:\n ret.append(self.term2id_dict[term])\n else:\n self.term2id_dict[term] = self.g_term_max_id\n self.id2term_dict[self.g_term_max_id] = term\n ret.append(self.g_term_max_id)\n self.g_term_max_id += 1\n return ret","def tokens(self) -> list:\n if self._tokens is None:\n tokens_ = sorted(list(self.elements()))\n self._tokens = tokens_\n return self._tokens","def get_gensim_dictionary(gensim_dictionary_model):\n return list(gensim_dictionary_model.token2id.keys())","def map_ids_to_tokens(self, ids: List[int], filter_padding=True):\n tokens = [self.map_id_to_token(id) for id in ids]\n if filter_padding:\n tokens = [t for t in tokens if t != self._pad_token]\n return tokens","def getTokens(self):\n # NOTE: seems to be used by the evitaNominalTrainer only\n tokenList = []\n for chunkOrToken in self.dtrs:\n if chunkOrToken.isToken():\n tokenList += [chunkOrToken]\n elif chunkOrToken.isChunk():\n tokenList += chunkOrToken.dtrs\n else:\n logger.warn(\"Sentence element that is not a chunk or token\")\n return tokenList","def getIDs():","def getTokens(self):\n return self.__token","def convert_tokens_to_ids(self, tokens, max_len=None):\n if max_len is not None:\n token_length = len(tokens)\n if max_len < token_length:\n tokens = tokens[:max_len]\n else:\n for _ in range(max_len - token_length):\n tokens.append(self.pad_token())\n return [self.stoi(tok) for tok in tokens]","def tokens(self):\n return self._tokens","def tokens(self):\n return self._tokens","def tokens(self):\n return self._tokens","def get_tokens(self):\r\n return TokenGroup.get_tokens(self._tu, self.extent)","def find_auth_token(document_html):\n search_result = re.search(AUTH_TOKEN_REGEX, document_html)\n if search_result:\n return search_result.group('auth_token')","def _get_docs_in_dir(dir_id):\n querystring = 'select docname from {} where dir_id = %s;'.format(TABLES[3])\n result = execute_query(querystring, (dir_id,))\n if result:\n return [x[0] for x in result]\n return []","def sentence_tokenize(tokenizer, sent):\n tokens = tokenizer.EncodeAsIds(sent).tokenization\n return tokens","def tokenLookup(instrument_df,symbol_list):\r\n token_list = []\r\n for symbol in symbol_list:\r\n token_list.append(int(instrument_df[instrument_df.tradingsymbol==symbol].instrument_token.values[0]))\r\n return token_list","def tokenLookup(instrument_df,symbol_list):\r\n token_list = []\r\n for symbol in symbol_list:\r\n token_list.append(int(instrument_df[instrument_df.tradingsymbol==symbol].instrument_token.values[0]))\r\n return token_list","def get_ids(cls, text):\n tokens = TokenizerContainer.TOKENIZER.tokenize(text)\n token_ids = TokenizerContainer.TOKENIZER.convert_tokens_to_ids(tokens)\n input_ids = token_ids + [0] * (cls.MAX_LEN-len(token_ids))\n return tokens, input_ids","def get_token_names(self) -> List[str]:\n return list(self._tokens.keys())","def sentence_to_token_ids(sentence, vocabulary):\n return [vocabulary.get(w, UNK_ID) for w in sentence.strip().split()]","def doc2idx(self, document, unknown_word_index=-1):\n if isinstance(document, string_types):\n raise TypeError(\"doc2idx expects an array of unicode tokens on input, not a single string\")\n\n document = [word if isinstance(word, unicode) else unicode(word, 'utf-8') for word in document]\n return [self.token2id.get(word, unknown_word_index) for word in document]","def tokenize_text(document, nlp):\n\n return [token.text for token in nlp(document)]","def tokens(self):\n return self.__tokens","def __get_lucene_contents(self, doc_id, en_list):\n contents = [{'field_name': Lucene.FIELDNAME_ID, 'field_value': doc_id, 'field_type': Lucene.FIELDTYPE_ID}]\n for en_id in en_list:\n contents.append({'field_name': \"content\", 'field_value': en_id, 'field_type': Lucene.FIELDTYPE_ID_TV})\n return contents","def list_revoked_tokens(self):\n raise exception.NotImplemented() # pragma: no cover","def getidlist(data: str = None) -> List[IDProfiler]:\n boxids: str = getinput(directory=DIR) if data is None else data\n idlist: List[IDProfiler] = list(map(IDProfiler, boxids.split(\"\\n\")))\n return idlist","def tokenLookup(instrument_df,symbol_list):\n token_list = []\n for symbol in symbol_list:\n token_list.append(int(instrument_df[instrument_df.tradingsymbol==symbol].instrument_token.values[0]))\n return token_list","def vectorize(tokens, vocab):\n ids = []\n for token in tokens:\n if token in vocab.tok2id:\n ids.append(vocab.tok2id[token])\n else:\n ids.append(vocab.tok2id[vocab.UNK])\n return ids","def getTokens(self):\n self.__require_privilaged_access()\n with DBSession(self.__config_db) as session:\n user = self.getLoggedInUser()\n sessionTokens = session.query(Session) \\\n .filter(Session.user_name == user) \\\n .filter(Session.can_expire.is_(False)) \\\n .all()\n\n result = []\n for t in sessionTokens:\n result.append(SessionTokenData(\n t.token,\n t.description,\n str(t.last_access)))\n\n return result","def get_annotation_list(\n self,\n project_id: int,\n doc_id: int\n ) -> requests.models.Response:\n return self.get(\n 'v1/projects/{project_id}/docs/{doc_id}/annotations'.format(\n project_id=project_id,\n doc_id=doc_id\n )\n )","def idsFromDocumentation(filename):\n\tidsInOrder = []\n\tsegment = \"\"\n\twith open(filename) as f:\n\t\tfor l in f:\n\t\t\tif \"<h2\" in l:\n\t\t\t\tsegment = l.split(\">\")[1].split(\"<\")[0]\n\t\t\tif 'id=\"SCI_' in l:\n\t\t\t\tidFeature = l.split('\"')[1]\n\t\t\t\t#~ print(idFeature)\n\t\t\t\tidsInOrder.append([segment, idFeature])\n\treturn idsInOrder","def get_token_id(self):\n return f\"{self.document_title}_{self.index}\"","def gettoken(tool_id, user_id):\n oauth_tokens = {\n 'access_token': '',\n 'user': {\n 'id': user_id\n }\n }\n params = {\n 'user_id': user_id\n }\n tokenq = \"\"\"select\naccess_token, refresh_token, expires_at, token_type, expires_in, user_name\nfrom tokens\nwhere user_id = :user_id\norder by expires_at desc\n\"\"\"\n tconn = dbconnect(CONFIG[CONFIG['app']['dbserver']])\n tcurr = tconn.cursor()\n try:\n results = tcurr.execute(tokenq, params).fetchone()\n except cx_Oracle.DatabaseError as err:\n LOG.error(\"Database error in retrieving tokens: %s\", err)\n\n if tcurr.rowcount > 0:\n oauth_tokens = {\n 'access_token': results[0],\n 'refresh_token': results[1],\n 'expires_at': results[2],\n 'token_type': results[3],\n 'expires_in': results[4],\n 'user': {\n 'name': results[5],\n 'id': user_id\n }\n }\n else:\n LOG.error(\"no token found for \" + str(tool_id) + ', ' + user_id)\n tcurr.close()\n tconn.close()\n return oauth_tokens","def tokenize_doc_simple(self, doc):\n\n tokens = [word.strip(string.punctuation) for word in doc.split()]\n # remove the empty string\n return [token for token in tokens if token]","def tokenizer(self, doc, lemmatize=False):\n doc = unicode(doc, \"utf-8\")\n if lemmatize:\n return [w.lemma_ for w in self.parser(doc)]\n else:\n return [w.text for w in self.parser(doc)]","def sequence_to_list_ids(sequence, vocab):\n pass","def getTokens(username):\n tokens = users.find({\"Username\": username})[0][\"Tokens\"]\n return tokens","def tokens(self):\r\n return self.iter_tokens(self._blob)","def get_translated_ids(id):","def get_read_tokens(mastertoken, config):\n mt_path = mastertoken['paths']['self']\n url = \"{}{}/read_tokens.json\".\\\n format(config['domain_base'], mt_path)\n\n try:\n resp = (api_call(url, 'get', config['debug']))\n tokens = resp.json()\n except ValueError as ex:\n abort(\"Unexpected response from packagecloud API: \"\n \"{}\".format(ex.message))\n\n return tokens['read_tokens']","def documents(pmid_23982599, civic_aid6_document):\n return [pmid_23982599, civic_aid6_document]","def sentence_to_token_ids(self,sentence, vocabulary,\n tokenizer=None, normalize_digits=True):\n if tokenizer:\n words = tokenizer(sentence)\n else:\n words = self.basic_tokenizer(sentence)\n\n if not normalize_digits:\n return [vocabulary.get(w, self.UNK_ID) for w in words]\n # Normalize digits by 0 before looking words up in the vocabulary.\n return [vocabulary.get(re.sub(PTBReader._DIGIT_RE, \" \", w), self.UNK_ID) for w in words]","def docs_to_list(documents):\n \n texts = [] \n for doc in documents:\n texts.append(doc.split())\n print ((\"The collection of documents contains {} documents\").format(len(texts)))\n return texts","def get_selected_elements(doc):\n try:\n # Revit 2016\n return [doc.GetElement(id)\n for id in __revit__.ActiveUIDocument.Selection.GetElementIds()]\n except:\n # old method\n return list(__revit__.ActiveUIDocument.Selection.Elements)"],"string":"[\n \"def doc2id(self, doc):\\n doc = map(self.process_token, doc)\\n return [self.token_to_id(token) for token in doc]\",\n \"def get_tokens(self, document):\\n raise NotImplementedError()\",\n \"def doc2token(self, doc):\\n return [self.word2idx[word] if self.word2idx.__contains__(word)\\n else self.word2idx['UNK'] for word in doc]\",\n \"def get_doc_ids(self):\\n cursor = self.connection.cursor()\\n cursor.execute(\\\"SELECT id FROM documents\\\")\\n results = [r[0] for r in cursor.fetchall()]\\n cursor.close()\\n return results\",\n \"def get_doc_ids(self):\\n cursor = self.connection.cursor()\\n cursor.execute(\\\"SELECT id FROM documents\\\")\\n results = [r[0] for r in cursor.fetchall()]\\n cursor.close()\\n return results\",\n \"def id2doc(self, ids):\\n return [self.id_to_token(idx) for idx in ids]\",\n \"def id2doc(self, ids):\\n return [self.id_to_token(idx) for idx in ids]\",\n \"def get_ids(self) -> List[str]:\",\n \"def tokens(self):\\n return self.rpc.call(MsfRpcMethod.AuthTokenList)['tokens']\",\n \"def keys(self):\\n return list(self.token2id.values())\",\n \"def get_ids(self,tokens, tokenizer, max_seq_length):\\n token_ids = tokenizer.convert_tokens_to_ids(tokens,)\\n input_ids = token_ids + [0] * (max_seq_length-len(token_ids))\\n return input_ids\",\n \"def convert_ids_to_tokens(self, tok_ids):\\n result = []\\n for tok in tok_ids:\\n word = self.itos(tok)\\n result.append(word)\\n return result\",\n \"def tok2idx_data(token2id, tok_data):\\n idx_data = []\\n for toks in tok_data:\\n idx_lst = [\\n token2id[tok] if tok in token2id else UNK_IDX for tok in toks]\\n idx_data.append(idx_lst)\\n return idx_data\",\n \"def convert_tokens_to_ids(self, tokens):\\n ids = []\\n for token in tokens:\\n ids.append(self.vocab[token])\\n if len(ids) > self.max_len:\\n logger.warning('Token indices sequence length is longer than the specified maximum sequence length for this BERT model ({} > {}). Running this sequence through BERT will result in indexing errors'.format(len(ids), self.max_len))\\n return ids\",\n \"def list_ids(token):\\n\\n init_tenant_context(token, db)\\n\\n data = []\\n LOGGER.debug(f\\\" Fetching list with known devices\\\")\\n for id in db.session.query(Device.id).all():\\n data.append(id[0])\\n return data\",\n \"def extarct_id_tf(docs):\\n\\n if len(docs) == 0:\\n return []\\n docs = docs.split(',')\\n ret = []\\n for doc in docs:\\n doc = doc.split('|')\\n # doc_id, tf\\n ret.append((int(doc[0]), int(doc[1])))\\n return ret\",\n \"def list_tokens(user):\\n return AppSpecificAuthToken.select().where(AppSpecificAuthToken.user == user)\",\n \"def list(uid: int):\\n\\n return Token.list(uid)\",\n \"def convert_tokens_to_ids(self, tokens):\\n ids = []\\n if isinstance(tokens, str):\\n if tokens in self.special_tokens:\\n return self.special_tokens[tokens]\\n else:\\n return self.encoder.get(tokens, self.unk_id)\\n for token in tokens:\\n if token in self.special_tokens:\\n ids.append(self.special_tokens[token])\\n else:\\n ids.append(self.encoder.get(token, self.unk_id))\\n return ids\",\n \"def get_ids(self, text):\\n\\n tokens = [token.orth for token in self.tokenizer(text)]\\n ids = []\\n for token in tokens:\\n try:\\n id = self.vocab.vectors.key2row[token]\\n except KeyError:\\n id = self.oov_id\\n\\n ids.append(id)\\n\\n return ids\",\n \"def get_tokens(self) -> List[str]:\\n return self.tokens\",\n \"def getReviewsWithToken(self, token):\\n\\n wordid = self.find_word_in_dictionary(token)\\n # word is not in the dictionary\\n if wordid == -1:\\n print(\\\"Token is not in the dictionary\\\")\\n return 0\\n\\n with open(self.doc_to_words_path, 'rb') as bin:\\n tup = []\\n while bin.tell() != os.fstat(bin.fileno()).st_size:\\n # get wordid:\\n docid_in_file = int.from_bytes(bin.read(4), 'big')\\n # get frequency:\\n frequency = int.from_bytes(bin.read(4), 'big')\\n # count words:\\n count = 0\\n for i in range(frequency):\\n wordid_in_file = int.from_bytes(bin.read(4), 'big')\\n if wordid == wordid_in_file:\\n count += 1\\n tup.append(docid_in_file)\\n tup.append(count)\\n return tuple(tup)\",\n \"def decode_ids_to_tokens(self, tokens: List[int]) -> List[str]:\\n token_list = self.tokenizer.ids_to_tokens(tokens)\\n return token_list\",\n \"def _get_vocab_id_list(self, json_obj):\\n return json_obj\",\n \"def get_ids(self, text):\\n\\n tokens = [token.orth for token in self.tokenizer(text)]\\n ids = []\\n for token in tokens:\\n try:\\n id = self._vocab.vectors.key2row[token]\\n except KeyError:\\n id = self.oov_id\\n\\n ids.append(id)\\n\\n return ids\",\n \"def get_document_tags(self, docid):\\n return [(key, json.loads(value))\\n for key, value\\n in self.sql_session.query(Feature)\\n .filter(Feature.document == docid)\\n .values(Feature.key, Feature.value)]\",\n \"def get_token_list():\\n token_list = []\\n tokens_dir_path = os.path.join(BASE_DIR, TOKENS_DIR)\\n for dir, dirs, files in os.walk(tokens_dir_path):\\n for file_name in files:\\n file = open(os.path.join(tokens_dir_path, file_name), 'r')\\n token_list.append(file.read().strip())\\n file.close()\\n return token_list\",\n \"def convert_ids_to_tokens(self, ids):\\n tokens = []\\n for i in ids:\\n tokens.append(self.ids_to_tokens[i])\\n return tokens\",\n \"def _get_doc_ids(dir_id, docname):\\n cur = conn.cursor(cursor_factory=pgx.RealDictCursor)\\n querystring = ('select id, source_docid, target_docid from {} where dir_id = %s and docname = %s;'\\n result = execute_query(querystring.format(TABLES[3])), (dir_id, docname))\\n if result:\\n return result['id'], result['source_docid'], result['target_docid']\\n return None, None, None\",\n \"def get_extent_token_ids(self, **kwargs):\\n token_span = self.get_extent_tokens(**kwargs)\\n return [t.index for t in token_span]\",\n \"def docs2ids(self):\\n self.docs = [ [self.vocab[word] for word in doc] for doc in self.docs]\",\n \"def get_doc_id_titles(self):\\n cursor = self.connection.cursor()\\n cursor.execute(\\\"SELECT id, title FROM documents\\\")\\n results = [(r[0], r[1]) for r in cursor.fetchall()]\\n cursor.close()\\n return results\",\n \"def tokenize(doc):\\n\\n # Calls NLTK function to tokenize the document. Broken into individual words, cleans out punctuation\\n tokens = nltk.word_tokenize(doc)\\n\\n return tokens\",\n \"def get_ids(self, sentence):\\n return [self.get_id(word) for word in sentence.strip().split(' ')]\",\n \"def get_ids(corpus):\\n corpusids = []\\n for chunk in corpus:\\n for _id in chunk.keys():\\n corpusids.append(_id)\\n return corpusids\",\n \"def tokens():\\n return ['access token', 'refresh token']\",\n \"def getTokens(self):\\n list = []\\n for i in range(self.startIdx, self.endIdx + 1):\\n token = self.sentence[i]\\n list.append(token)\\n return list\",\n \"def get_tokens(self):\\r\\n return self.token_set\",\n \"def fetch_doc_tokens(self, document_level, find_query_mixin={}):\\n if document_level != 'postwise':\\n raise NotImplementedError('document_level:%s' % document_level)\\n\\n query = {'subreddit':self.subreddit, document_level:{'$exists':True}}\\n query.update(find_query_mixin)\\n\\n for doc in self.posts_read.find(query):\\n try:\\n yield doc[document_level]['tokens']\\n except KeyError:\\n # XXX: this shouldn't happen...\\n print 'woop, doc missing %s.tokens' % document_level\",\n \"def get_all_group_ids(token) -> list:\\n ids=list()\\n _dict = perform_request(app_config.ENDPOINT, token)\\n while True:\\n for obj in _dict[\\\"value\\\"]:\\n ids.append(obj[\\\"id\\\"])\\n if \\\"@odata.nextLink\\\" not in _dict:\\n return ids\\n _dict = perform_request(_dict[\\\"@odata.nextLink\\\"], token)\",\n \"def get_positions(token, docs):\\n\\n all_matches = [token]\\n for doc in docs:\\n matches = []\\n if token in doc:\\n indexes = [i for i, x in enumerate(doc) if x == token]\\n matches += [docs.index(doc), len(indexes), indexes]\\n if matches:\\n all_matches.append(matches)\\n return all_matches\",\n \"def docs(self, searcher, exclude_docs=None):\\r\\n\\r\\n try:\\r\\n return self.matcher(searcher, exclude_docs=exclude_docs).all_ids()\\r\\n except TermNotFound:\\r\\n return []\",\n \"def get_token_list(text):\\n return text.split()\",\n \"def _token_to_id(self, sequence_tokens, token_map, char_map, ngram=0,\\n token_ngram_map=None, max_char_sequence_length=-1,\\n max_char_length_per_token=-1):\\n token_id_list = []\\n char_id_list = []\\n char_in_token_id_list = []\\n ngram_id_list = []\\n for token in sequence_tokens:\\n char_id = [char_map.get(x, self.VOCAB_UNKNOWN) for x in token]\\n char_id_list.extend(char_id[0:max_char_sequence_length])\\n char_in_token = [char_map.get(x, self.VOCAB_UNKNOWN)\\n for x in token[0:max_char_length_per_token]]\\n char_in_token_id_list.append(char_in_token)\\n\\n token_id_list.append(\\n token_map.get(token, token_map[self.VOCAB_UNKNOWN]))\\n if ngram > 1:\\n for j in range(2, ngram + 1):\\n ngram_id_list.extend(\\n token_ngram_map[x] for x in\\n [\\\"\\\".join(sequence_tokens[k:k + j]) for k in\\n range(len(sequence_tokens) - j + 1)] if x in\\n token_ngram_map)\\n if not sequence_tokens:\\n token_id_list.append(self.VOCAB_PADDING)\\n char_id_list.append(self.VOCAB_PADDING)\\n char_in_token_id_list.append([self.VOCAB_PADDING])\\n if not ngram_id_list:\\n ngram_id_list.append(token_ngram_map[self.VOCAB_PADDING])\\n return token_id_list, char_id_list, char_in_token_id_list, ngram_id_list\",\n \"def queryByDocId(self, docId):\\n\\n table = self.__getTable()\\n return (row['entity'] for row in table.query_2(\\n docId__eq = docId,\\n index = 'docIdIndex'))\",\n \"def print_doc_tokens(doc):\\n tokens = []\\n for token in doc:\\n tokens.append([token.text, token.pos_, token.dep_, token.tag_])\\n\\n df = pd.DataFrame(tokens, columns=[\\\"text\\\", \\\"part-of-speech\\\", \\\"syntactic_dependency_relation\\\", \\\"tag\\\"])\\n return df\",\n \"def get_token(self, bot_id):\\n res = self.execute(TABELLE['bot']['select']['by_id'], (bot_id,))\\n # print(res)\\n return res\",\n \"def tokens(self):\\n # type: () -> List[Token]\\n return self._tokens\",\n \"def _list_tokens(self, user_id, tenant_id=None, trust_id=None,\\n consumer_id=None):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def map_tokens_to_ids(self, tokens: List[str], max_length: int = None):\\n # truncate extra tokens and pad to `max_length`\\n if max_length:\\n tokens = tokens[:max_length]\\n tokens = tokens + [self._pad_token]*(max_length-len(tokens))\\n return [self.map_token_to_id(token) for token in tokens]\",\n \"def iter_docids(self):\\n return iter(self.client.smembers(self.dbprefix + 'docs'))\",\n \"def _get_token_ids(self, tokens):\\n token_ids = self.tokenizer.convert_tokens_to_ids(tokens)\\n pad_amount = self.max_seq_length - len(tokens)\\n input_ids = token_ids + [0] * pad_amount\\n return np.array(input_ids)\",\n \"def documents(self, **kw):\\r\\n \\r\\n doc_reader = self.doc_reader\\r\\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))\",\n \"def get_ids_logs(doc):\\n\\n doc['ids'] = []\\n\\n with open('/var/log/suricata/eve.json', 'r') as f:\\n for line in f:\\n #lets go ahead and deserialize the log and pull out sig field\\n sig = json.loads(line)['alert']['signature']\\n #blergh, too lazy to comment out of suricata, or change UA\\n if sig != \\\"ET POLICY Python-urllib/ Suspicious User Agent\\\":\\n doc['ids'].append(sig)\\n\\n #add a check for empty ids file and lets just remove the field\\n if len(doc['ids']) == 0:\\n doc.pop('ids')\\n return doc\\n\\n return doc\",\n \"def ids(self):\\n return (x[\\\"_id\\\"] for x in self.document._meta.collection.find(self.spec, fields = (\\\"_id\\\",)))\",\n \"def tokens(self):\\n\\t\\tlabels_and_synonyms = list(itertools.chain.from_iterable(list(self.term_to_tokens.values())))\\n\\t\\ttokens = set(list(itertools.chain.from_iterable([word_tokenize(x) for x in labels_and_synonyms])))\\n\\t\\treturn(list(tokens))\",\n \"def _tokens_to_terms(self, tokens: Sequence[str]) -> List[int]:\\n ret = []\\n for t in tokens:\\n term = self.stemmer(t)\\n if term in self.term2id_dict:\\n ret.append(self.term2id_dict[term])\\n else:\\n self.term2id_dict[term] = self.g_term_max_id\\n self.id2term_dict[self.g_term_max_id] = term\\n ret.append(self.g_term_max_id)\\n self.g_term_max_id += 1\\n return ret\",\n \"def tokens(self) -> list:\\n if self._tokens is None:\\n tokens_ = sorted(list(self.elements()))\\n self._tokens = tokens_\\n return self._tokens\",\n \"def get_gensim_dictionary(gensim_dictionary_model):\\n return list(gensim_dictionary_model.token2id.keys())\",\n \"def map_ids_to_tokens(self, ids: List[int], filter_padding=True):\\n tokens = [self.map_id_to_token(id) for id in ids]\\n if filter_padding:\\n tokens = [t for t in tokens if t != self._pad_token]\\n return tokens\",\n \"def getTokens(self):\\n # NOTE: seems to be used by the evitaNominalTrainer only\\n tokenList = []\\n for chunkOrToken in self.dtrs:\\n if chunkOrToken.isToken():\\n tokenList += [chunkOrToken]\\n elif chunkOrToken.isChunk():\\n tokenList += chunkOrToken.dtrs\\n else:\\n logger.warn(\\\"Sentence element that is not a chunk or token\\\")\\n return tokenList\",\n \"def getIDs():\",\n \"def getTokens(self):\\n return self.__token\",\n \"def convert_tokens_to_ids(self, tokens, max_len=None):\\n if max_len is not None:\\n token_length = len(tokens)\\n if max_len < token_length:\\n tokens = tokens[:max_len]\\n else:\\n for _ in range(max_len - token_length):\\n tokens.append(self.pad_token())\\n return [self.stoi(tok) for tok in tokens]\",\n \"def tokens(self):\\n return self._tokens\",\n \"def tokens(self):\\n return self._tokens\",\n \"def tokens(self):\\n return self._tokens\",\n \"def get_tokens(self):\\r\\n return TokenGroup.get_tokens(self._tu, self.extent)\",\n \"def find_auth_token(document_html):\\n search_result = re.search(AUTH_TOKEN_REGEX, document_html)\\n if search_result:\\n return search_result.group('auth_token')\",\n \"def _get_docs_in_dir(dir_id):\\n querystring = 'select docname from {} where dir_id = %s;'.format(TABLES[3])\\n result = execute_query(querystring, (dir_id,))\\n if result:\\n return [x[0] for x in result]\\n return []\",\n \"def sentence_tokenize(tokenizer, sent):\\n tokens = tokenizer.EncodeAsIds(sent).tokenization\\n return tokens\",\n \"def tokenLookup(instrument_df,symbol_list):\\r\\n token_list = []\\r\\n for symbol in symbol_list:\\r\\n token_list.append(int(instrument_df[instrument_df.tradingsymbol==symbol].instrument_token.values[0]))\\r\\n return token_list\",\n \"def tokenLookup(instrument_df,symbol_list):\\r\\n token_list = []\\r\\n for symbol in symbol_list:\\r\\n token_list.append(int(instrument_df[instrument_df.tradingsymbol==symbol].instrument_token.values[0]))\\r\\n return token_list\",\n \"def get_ids(cls, text):\\n tokens = TokenizerContainer.TOKENIZER.tokenize(text)\\n token_ids = TokenizerContainer.TOKENIZER.convert_tokens_to_ids(tokens)\\n input_ids = token_ids + [0] * (cls.MAX_LEN-len(token_ids))\\n return tokens, input_ids\",\n \"def get_token_names(self) -> List[str]:\\n return list(self._tokens.keys())\",\n \"def sentence_to_token_ids(sentence, vocabulary):\\n return [vocabulary.get(w, UNK_ID) for w in sentence.strip().split()]\",\n \"def doc2idx(self, document, unknown_word_index=-1):\\n if isinstance(document, string_types):\\n raise TypeError(\\\"doc2idx expects an array of unicode tokens on input, not a single string\\\")\\n\\n document = [word if isinstance(word, unicode) else unicode(word, 'utf-8') for word in document]\\n return [self.token2id.get(word, unknown_word_index) for word in document]\",\n \"def tokenize_text(document, nlp):\\n\\n return [token.text for token in nlp(document)]\",\n \"def tokens(self):\\n return self.__tokens\",\n \"def __get_lucene_contents(self, doc_id, en_list):\\n contents = [{'field_name': Lucene.FIELDNAME_ID, 'field_value': doc_id, 'field_type': Lucene.FIELDTYPE_ID}]\\n for en_id in en_list:\\n contents.append({'field_name': \\\"content\\\", 'field_value': en_id, 'field_type': Lucene.FIELDTYPE_ID_TV})\\n return contents\",\n \"def list_revoked_tokens(self):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def getidlist(data: str = None) -> List[IDProfiler]:\\n boxids: str = getinput(directory=DIR) if data is None else data\\n idlist: List[IDProfiler] = list(map(IDProfiler, boxids.split(\\\"\\\\n\\\")))\\n return idlist\",\n \"def tokenLookup(instrument_df,symbol_list):\\n token_list = []\\n for symbol in symbol_list:\\n token_list.append(int(instrument_df[instrument_df.tradingsymbol==symbol].instrument_token.values[0]))\\n return token_list\",\n \"def vectorize(tokens, vocab):\\n ids = []\\n for token in tokens:\\n if token in vocab.tok2id:\\n ids.append(vocab.tok2id[token])\\n else:\\n ids.append(vocab.tok2id[vocab.UNK])\\n return ids\",\n \"def getTokens(self):\\n self.__require_privilaged_access()\\n with DBSession(self.__config_db) as session:\\n user = self.getLoggedInUser()\\n sessionTokens = session.query(Session) \\\\\\n .filter(Session.user_name == user) \\\\\\n .filter(Session.can_expire.is_(False)) \\\\\\n .all()\\n\\n result = []\\n for t in sessionTokens:\\n result.append(SessionTokenData(\\n t.token,\\n t.description,\\n str(t.last_access)))\\n\\n return result\",\n \"def get_annotation_list(\\n self,\\n project_id: int,\\n doc_id: int\\n ) -> requests.models.Response:\\n return self.get(\\n 'v1/projects/{project_id}/docs/{doc_id}/annotations'.format(\\n project_id=project_id,\\n doc_id=doc_id\\n )\\n )\",\n \"def idsFromDocumentation(filename):\\n\\tidsInOrder = []\\n\\tsegment = \\\"\\\"\\n\\twith open(filename) as f:\\n\\t\\tfor l in f:\\n\\t\\t\\tif \\\"<h2\\\" in l:\\n\\t\\t\\t\\tsegment = l.split(\\\">\\\")[1].split(\\\"<\\\")[0]\\n\\t\\t\\tif 'id=\\\"SCI_' in l:\\n\\t\\t\\t\\tidFeature = l.split('\\\"')[1]\\n\\t\\t\\t\\t#~ print(idFeature)\\n\\t\\t\\t\\tidsInOrder.append([segment, idFeature])\\n\\treturn idsInOrder\",\n \"def get_token_id(self):\\n return f\\\"{self.document_title}_{self.index}\\\"\",\n \"def gettoken(tool_id, user_id):\\n oauth_tokens = {\\n 'access_token': '',\\n 'user': {\\n 'id': user_id\\n }\\n }\\n params = {\\n 'user_id': user_id\\n }\\n tokenq = \\\"\\\"\\\"select\\naccess_token, refresh_token, expires_at, token_type, expires_in, user_name\\nfrom tokens\\nwhere user_id = :user_id\\norder by expires_at desc\\n\\\"\\\"\\\"\\n tconn = dbconnect(CONFIG[CONFIG['app']['dbserver']])\\n tcurr = tconn.cursor()\\n try:\\n results = tcurr.execute(tokenq, params).fetchone()\\n except cx_Oracle.DatabaseError as err:\\n LOG.error(\\\"Database error in retrieving tokens: %s\\\", err)\\n\\n if tcurr.rowcount > 0:\\n oauth_tokens = {\\n 'access_token': results[0],\\n 'refresh_token': results[1],\\n 'expires_at': results[2],\\n 'token_type': results[3],\\n 'expires_in': results[4],\\n 'user': {\\n 'name': results[5],\\n 'id': user_id\\n }\\n }\\n else:\\n LOG.error(\\\"no token found for \\\" + str(tool_id) + ', ' + user_id)\\n tcurr.close()\\n tconn.close()\\n return oauth_tokens\",\n \"def tokenize_doc_simple(self, doc):\\n\\n tokens = [word.strip(string.punctuation) for word in doc.split()]\\n # remove the empty string\\n return [token for token in tokens if token]\",\n \"def tokenizer(self, doc, lemmatize=False):\\n doc = unicode(doc, \\\"utf-8\\\")\\n if lemmatize:\\n return [w.lemma_ for w in self.parser(doc)]\\n else:\\n return [w.text for w in self.parser(doc)]\",\n \"def sequence_to_list_ids(sequence, vocab):\\n pass\",\n \"def getTokens(username):\\n tokens = users.find({\\\"Username\\\": username})[0][\\\"Tokens\\\"]\\n return tokens\",\n \"def tokens(self):\\r\\n return self.iter_tokens(self._blob)\",\n \"def get_translated_ids(id):\",\n \"def get_read_tokens(mastertoken, config):\\n mt_path = mastertoken['paths']['self']\\n url = \\\"{}{}/read_tokens.json\\\".\\\\\\n format(config['domain_base'], mt_path)\\n\\n try:\\n resp = (api_call(url, 'get', config['debug']))\\n tokens = resp.json()\\n except ValueError as ex:\\n abort(\\\"Unexpected response from packagecloud API: \\\"\\n \\\"{}\\\".format(ex.message))\\n\\n return tokens['read_tokens']\",\n \"def documents(pmid_23982599, civic_aid6_document):\\n return [pmid_23982599, civic_aid6_document]\",\n \"def sentence_to_token_ids(self,sentence, vocabulary,\\n tokenizer=None, normalize_digits=True):\\n if tokenizer:\\n words = tokenizer(sentence)\\n else:\\n words = self.basic_tokenizer(sentence)\\n\\n if not normalize_digits:\\n return [vocabulary.get(w, self.UNK_ID) for w in words]\\n # Normalize digits by 0 before looking words up in the vocabulary.\\n return [vocabulary.get(re.sub(PTBReader._DIGIT_RE, \\\" \\\", w), self.UNK_ID) for w in words]\",\n \"def docs_to_list(documents):\\n \\n texts = [] \\n for doc in documents:\\n texts.append(doc.split())\\n print ((\\\"The collection of documents contains {} documents\\\").format(len(texts)))\\n return texts\",\n \"def get_selected_elements(doc):\\n try:\\n # Revit 2016\\n return [doc.GetElement(id)\\n for id in __revit__.ActiveUIDocument.Selection.GetElementIds()]\\n except:\\n # old method\\n return list(__revit__.ActiveUIDocument.Selection.Elements)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71084183","0.6638949","0.64065033","0.6308615","0.6308615","0.6248695","0.6248695","0.616698","0.61223453","0.60448986","0.6016193","0.6015829","0.6009144","0.59384847","0.5869318","0.5861415","0.5859866","0.5852833","0.58410364","0.5834465","0.5816366","0.58008885","0.58006424","0.5793585","0.5777246","0.5777149","0.5776924","0.57598704","0.5750446","0.5728729","0.57229066","0.5673558","0.5648633","0.5647172","0.5640797","0.5634816","0.5618087","0.56151867","0.5613221","0.55854183","0.5532098","0.55294013","0.5519083","0.55122906","0.5475321","0.5472813","0.54664356","0.54651076","0.5437001","0.5432145","0.54201746","0.54098976","0.5395683","0.5386548","0.5382212","0.5367989","0.5361271","0.5351235","0.53112555","0.53073","0.53048784","0.53008157","0.52842635","0.52715623","0.5267278","0.5267278","0.5267278","0.5266966","0.52251","0.5224945","0.52134204","0.5205132","0.5205132","0.5191797","0.51915705","0.5190645","0.51888317","0.51795524","0.5169762","0.51609653","0.51598483","0.5158202","0.51499367","0.51421475","0.5136696","0.513505","0.5134813","0.5134546","0.5126149","0.5124109","0.5122007","0.5116739","0.5111097","0.5110712","0.51106024","0.510913","0.51055485","0.5094392","0.5073104","0.5069208"],"string":"[\n \"0.71084183\",\n \"0.6638949\",\n \"0.64065033\",\n \"0.6308615\",\n \"0.6308615\",\n \"0.6248695\",\n \"0.6248695\",\n \"0.616698\",\n \"0.61223453\",\n \"0.60448986\",\n \"0.6016193\",\n \"0.6015829\",\n \"0.6009144\",\n \"0.59384847\",\n \"0.5869318\",\n \"0.5861415\",\n \"0.5859866\",\n \"0.5852833\",\n \"0.58410364\",\n \"0.5834465\",\n \"0.5816366\",\n \"0.58008885\",\n \"0.58006424\",\n \"0.5793585\",\n \"0.5777246\",\n \"0.5777149\",\n \"0.5776924\",\n \"0.57598704\",\n \"0.5750446\",\n \"0.5728729\",\n \"0.57229066\",\n \"0.5673558\",\n \"0.5648633\",\n \"0.5647172\",\n \"0.5640797\",\n \"0.5634816\",\n \"0.5618087\",\n \"0.56151867\",\n \"0.5613221\",\n \"0.55854183\",\n \"0.5532098\",\n \"0.55294013\",\n \"0.5519083\",\n \"0.55122906\",\n \"0.5475321\",\n \"0.5472813\",\n \"0.54664356\",\n \"0.54651076\",\n \"0.5437001\",\n \"0.5432145\",\n \"0.54201746\",\n \"0.54098976\",\n \"0.5395683\",\n \"0.5386548\",\n \"0.5382212\",\n \"0.5367989\",\n \"0.5361271\",\n \"0.5351235\",\n \"0.53112555\",\n \"0.53073\",\n \"0.53048784\",\n \"0.53008157\",\n \"0.52842635\",\n \"0.52715623\",\n \"0.5267278\",\n \"0.5267278\",\n \"0.5267278\",\n \"0.5266966\",\n \"0.52251\",\n \"0.5224945\",\n \"0.52134204\",\n \"0.5205132\",\n \"0.5205132\",\n \"0.5191797\",\n \"0.51915705\",\n \"0.5190645\",\n \"0.51888317\",\n \"0.51795524\",\n \"0.5169762\",\n \"0.51609653\",\n \"0.51598483\",\n \"0.5158202\",\n \"0.51499367\",\n \"0.51421475\",\n \"0.5136696\",\n \"0.513505\",\n \"0.5134813\",\n \"0.5134546\",\n \"0.5126149\",\n \"0.5124109\",\n \"0.5122007\",\n \"0.5116739\",\n \"0.5111097\",\n \"0.5110712\",\n \"0.51106024\",\n \"0.510913\",\n \"0.51055485\",\n \"0.5094392\",\n \"0.5073104\",\n \"0.5069208\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6642477"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":7385,"cells":{"query":{"kind":"string","value":"Get the token list."},"document":{"kind":"string","value":"def id2doc(self, ids):\n return [self.id_to_token(idx) for idx in ids]"},"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_tokens(self) -> List[str]:\n return self.tokens","def tokens(self):\n # type: () -> List[Token]\n return self._tokens","def tokens(self):\n return self.rpc.call(MsfRpcMethod.AuthTokenList)['tokens']","def get_tokens(self):\r\n return self.token_set","def get_token_list():\n token_list = []\n tokens_dir_path = os.path.join(BASE_DIR, TOKENS_DIR)\n for dir, dirs, files in os.walk(tokens_dir_path):\n for file_name in files:\n file = open(os.path.join(tokens_dir_path, file_name), 'r')\n token_list.append(file.read().strip())\n file.close()\n return token_list","def getTokens(self):\n return self.__token","def tokens(self):\n return self.__tokens","def tokens(self):\n return self._tokens","def tokens(self):\n return self._tokens","def tokens(self):\n return self._tokens","def tokens(self) -> list:\n if self._tokens is None:\n tokens_ = sorted(list(self.elements()))\n self._tokens = tokens_\n return self._tokens","def getTokens(self):\n list = []\n for i in range(self.startIdx, self.endIdx + 1):\n token = self.sentence[i]\n list.append(token)\n return list","def get_token_names(self) -> List[str]:\n return list(self._tokens.keys())","def get_tokens(self):\r\n return TokenGroup.get_tokens(self._tu, self.extent)","def get_Tokens(self):\n return self._output.get('Tokens', None)","def get_token_list(text):\n return text.split()","def tokens():\n return ['access token', 'refresh token']","def all_tokens(self) -> List[Hashable]:\n return self._all_tokens","def list(uid: int):\n\n return Token.list(uid)","def list_tokens(self) -> str:\n\n return self._format_symbol_table_content(\"Tokens\", self._symbols.keys())","def get_tokens(self):\n def _traverse_preorder(cursor, token_list): # There is a method called \"walk_preorder\" in Cursor class. Here we need to ignore some subtrees so we implement on our own.\n if cursor.location.file and cursor.location.file.name != self.filepath: # exclude \"#include <...>\"\n return\n if (cursor.kind, cursor.spelling) in exclude_types: # exclude node in 'exclude_types'\n return\n \n token_list.append(cursor)\n for child in cursor.get_children():\n _traverse_preorder(child, token_list)\n\n tokens = []\n _traverse_preorder(self.cursor, tokens)\n return tokens","def getTokens(self):\n self.__require_privilaged_access()\n with DBSession(self.__config_db) as session:\n user = self.getLoggedInUser()\n sessionTokens = session.query(Session) \\\n .filter(Session.user_name == user) \\\n .filter(Session.can_expire.is_(False)) \\\n .all()\n\n result = []\n for t in sessionTokens:\n result.append(SessionTokenData(\n t.token,\n t.description,\n str(t.last_access)))\n\n return result","def token_values(self):\n return self._token_values","def getTokens(self):\n # NOTE: seems to be used by the evitaNominalTrainer only\n tokenList = []\n for chunkOrToken in self.dtrs:\n if chunkOrToken.isToken():\n tokenList += [chunkOrToken]\n elif chunkOrToken.isChunk():\n tokenList += chunkOrToken.dtrs\n else:\n logger.warn(\"Sentence element that is not a chunk or token\")\n return tokenList","def tokens(self):\n tokens = []\n for index in range(len(self.sentrep)):\n tokens.append(self.sentrep.getWord(index).lexeme())\n return tokens","def tokens(self):\r\n return self.iter_tokens(self._blob)","def get_tokens(self, document):\n raise NotImplementedError()","def get_tokens(self):\n\t\treturn self.get_starttokens() + self.get_endtokens()","def tokens(self):\r\n return Tokens(self)","def __repr__(self) -> str:\n return \"<Twilio.Oauth.V1.TokenList>\"","def tokens(self):\n return self._sentrep.tokens()","def get_tokens(self, *args, **kwargs) -> List[Token]:\n for text in args:\n for char in text:\n self.set_tokens(char)\n self.flush_temp()\n\n return self.tokens","def tokens(self):\n\t\tlabels_and_synonyms = list(itertools.chain.from_iterable(list(self.term_to_tokens.values())))\n\t\ttokens = set(list(itertools.chain.from_iterable([word_tokenize(x) for x in labels_and_synonyms])))\n\t\treturn(list(tokens))","def get_tokens():\n return (HDFS_SITE_KEY, NAMESERVICE_KEY, NN_HTTP_ADDRESS_KEY, DFS_POLICY_KEY,\n EXECUTABLE_SEARCH_PATHS, NN_HTTPS_ADDRESS_KEY, SMOKEUSER_KEY,\n KERBEROS_KEYTAB, KERBEROS_PRINCIPAL, SECURITY_ENABLED_KEY,\n METRICS_COLLECTOR_VIP_HOST_KEY, METRICS_COLLECTOR_VIP_PORT_KEY,\n METRICS_COLLECTOR_WEBAPP_ADDRESS_KEY, AMS_HTTP_POLICY)","def bearer_tokens(self):\n return self._bearer_tokens","def list_revoked_tokens(self):\n raise exception.NotImplemented() # pragma: no cover","def special_tokens(self) -> List[Hashable]:\n return list(self._special_token_kv.values())","def synth_tokens(self):\n if self.lliagraph:\n return self.lliagraph.synth_tokens.items()\n else:\n return []","def getList(self):\n pass","def get_token_types() -> List[type]:\n return ExtensionTokenTypes.__TOKEN_TYPES","def getList(self):\n\treturn self.list","def list_tokens(user):\n return AppSpecificAuthToken.select().where(AppSpecificAuthToken.user == user)","def getToken(self):\n \n raise NotImplementedError","def getList(self):","def getList(self):","def get_read_tokens(mastertoken, config):\n mt_path = mastertoken['paths']['self']\n url = \"{}{}/read_tokens.json\".\\\n format(config['domain_base'], mt_path)\n\n try:\n resp = (api_call(url, 'get', config['debug']))\n tokens = resp.json()\n except ValueError as ex:\n abort(\"Unexpected response from packagecloud API: \"\n \"{}\".format(ex.message))\n\n return tokens['read_tokens']","def tokens():\n pass","def get_list_of_tokens(self, to_lower=True, remove_newlines=True):\n if not self.tokens:\n assert self.url, \"Wrong url provided!\"\n self.text = self._get_text(remove_newlines=remove_newlines)\n self.log.debug(u\"First 100 characters of text from {url}: {text}\"\n \"\".format(url=self.url,\n text=self.text[:100]))\n self.tokens = self._get_tokens()\n self.log.debug(u\"First 100 tokens of text from {url}: {tokens}\"\n \"\".format(url=self.url,\n tokens=self.tokens))\n if to_lower:\n # all words to lowercase\n self.tokens = list(map(lambda s: s.lower(), self.tokens))\n return self.tokens","def getList(self):\n return self.list","def tokens(self):\n return tuple(self._tree.getWords())","def tokenize(self):\n tknzr = TweetTokenizer()\n tkn = []\n for tweet in self.tweets:\n for word in tknzr.tokenize(tweet):\n tkn.append(word)\n return tkn","def getList(self):\n return self.list_","def get_tokens(self, text):\n if text is not None:\n text = text.strip()\n words = self.safe_split(text)\n return words\n return []","def get(self, filters=None, pagination=None, sort=None):\n filters = filters or {}\n if not is_user_action_allowed('manage_others_tokens'):\n filters['_user_fk'] = current_user.id\n\n sm = get_storage_manager()\n\n result = sm.list(models.Token, filters=filters,\n pagination=pagination, sort=sort)\n\n return result","def keys(self):\n return list(self.token2id.values())","def list(self):\n return self._get_list()","def parse(self) -> List[List[Union[str,int]]]:\n return self.__create_list(cp(self.tokens))","def get_tokens():\n return (ZEPPELIN_USER_KEY, UI_SSL_ENABLED, SECURITY_ENABLED_KEY, ZEPPELIN_KEYTAB_KEY, ZEPPELIN_PRINCIPAL_KEY,\n KERBEROS_EXECUTABLE_SEARCH_PATHS_KEY, ZEPPELIN_PORT_KEY, ZEPPELIN_PORT_SSL_KEY)","def tokens(self):\n tokens = [k for k in self.tok2ind.keys()\n if k not in {'<NULL>', '<UNK>'}]\n return tokens","def word_list(self) -> List[str]:\n return self._word_list","def tokens_and_tags(self):\n return list(zip(self.tokens(), self.tags()))","def token_lookup():\n token_list = {\".\": \"||Period||\",\n \",\": \"||Comma||\",\n '\"': \"|Quotation_Mark||\",\n \";\": \"||Semicolon||\",\n \"!\": \"||Exclamation_Mark||\",\n \"?\": \"||Question_Mark||\",\n \"(\": \"||Left_Parentheses||\",\n \")\": \"||Right_Parentheses||\",\n \"--\": \"||Dash||\",\n \"\\n\": \"||Return||\"\n }\n\n return token_list","def get_read_tokens_dict(mastertoken, config):\n token_list = {}\n tokens = get_read_tokens(mastertoken, config)\n\n for token in tokens:\n if token['name']:\n token_list[token['name']] = token['value']\n if config['debug']:\n print(\"DEBUG: Found token {} with value {}\".\n format(token['name'], token['value']))\n\n return token_list","def get_commands_list() -> list:\n return open(\"data/metadata/commands.list.txt\", \"r\").read().split(\"\\n\")","def get_components(self):\r\n return [Token.from_multiword(word, index, self) for index, word in enumerate(self.wordform.split('_'))]","def getTokens(username):\n tokens = users.find({\"Username\": username})[0][\"Tokens\"]\n return tokens","def get_list(key):\n ret = hookenv.action_get(key)\n return ret.split() if ret else []","def get_tokens(self, node, include_extra=False):\n # type: (AstNode, bool) -> Iterator[Token]\n return self.token_range(node.first_token, node.last_token, include_extra=include_extra)","def importantTokenList(self, ignoreSemanticTagList=[]):\n list = tokenlist.TokenList()\n for token in self.tokens:\n if token.isAcronym():\n expansion = token.getAcronymExpansion()\n \n# print token.text, '=', \n# for t in expansion:\n# print t.text,\n# print\n\n# list.append(token)\n# for t in token.getAcronymExpansion():\n# if self.isImportantToken(t):\n# list.append(t)\n\n if expansion == None or len(expansion) == 0:\n list.append(token)\n else:\n for t in token.getAcronymExpansion():\n if self.isImportantToken(t, ignoreSemanticTagList=ignoreSemanticTagList):\n list.append(t)\n elif self.isImportantToken(token, ignoreSemanticTagList=ignoreSemanticTagList):\n list.append(token)\n \n return list","def __create_list(self, tokens : List[Union[str,int]]) -> List[List[Union[str,int]]]:\n if tokens:\n return [self.__add_instruction(cp(tokens[:1+syntaxParametersDict.get(tokens[0])]))] + self.__create_list(cp(tokens[1+syntaxParametersDict.get(tokens[0]):]))\n return []","def get_symbols_list(self):\n return self.symbols_list","def tokenize(cls, selector):\n\n cls.lexer.input(selector)\n token_list = []\n while True:\n token = cls.lexer.token()\n if not token: break\n token_list.append(token)\n return token_list","def _list_tokens(self, user_id, tenant_id=None, trust_id=None,\n consumer_id=None):\n raise exception.NotImplemented() # pragma: no cover","def listTags(self, authenticationToken):\r\n pass","def tokens(self):\n data, end = \\\n self.pat.traverse(lambda obj, *args: obj.tokens(*args),\n self.begin, self.data)\n return data","def get_nft_list(self):\n tokens = self.api.find_all(\"nft\", \"nfts\", query={})\n return tokens","def parse_token_list(data):\n\n state = http_header_util.ParsingState(data)\n\n token_list = []\n\n while True:\n token = http_header_util.consume_token(state)\n if token is not None:\n token_list.append(token)\n\n http_header_util.consume_lwses(state)\n\n if http_header_util.peek(state) is None:\n break\n\n if not http_header_util.consume_string(state, ','):\n raise HandshakeException(\n 'Expected a comma but found %r' % http_header_util.peek(state))\n\n http_header_util.consume_lwses(state)\n\n if len(token_list) == 0:\n raise HandshakeException('No valid token found')\n\n return token_list","def _next_tokens(self, head):\n state = head.state\n input_str = self.input_str\n position = head.position\n actions = state.actions\n in_len = len(input_str)\n tokens = []\n\n # add special STOP token if they are applicable\n if STOP in actions:\n if not self.consume_input \\\n or (self.consume_input and position == in_len):\n tokens.append(STOP_token)\n\n if position < in_len:\n # Get tokens by trying recognizers - but only if we are not at\n # the end, because token cannot be empty\n if self.custom_token_recognition:\n def get_tokens():\n return self._token_recognition(head)\n\n custom_tokens = self.custom_token_recognition(\n head, get_tokens,\n )\n if custom_tokens is not None:\n tokens.extend(custom_tokens)\n else:\n tokens.extend(self._token_recognition(head))\n\n # do lexical disambiguation if it is enabled\n if self.lexical_disambiguation:\n tokens = self._lexical_disambiguation(tokens)\n\n return tokens","def getList(self):\n\treturn self.sorted_list.getList()","def _next_tokens(self, context):\n state = context.state\n input_str = context.input_str\n position = context.position\n actions = state.actions\n in_len = len(input_str)\n tokens = []\n\n # add special tokens (EMPTY and STOP) if they are applicable\n if EMPTY in actions:\n tokens.append(EMPTY_token)\n if STOP in actions:\n if not self.consume_input \\\n or (self.consume_input and position == in_len):\n tokens.append(STOP_token)\n\n if position < in_len:\n # Get tokens by trying recognizers - but only if we are not at\n # the end, because token cannot be empty\n if self.custom_token_recognition:\n def get_tokens():\n return self._token_recognition(context)\n\n custom_tokens = self.custom_token_recognition(\n context, get_tokens,\n )\n if custom_tokens is not None:\n tokens.extend(custom_tokens)\n else:\n tokens.extend(self._token_recognition(context))\n\n # do lexical disambiguation if it is enabled\n if self.lexical_disambiguation:\n tokens = self._lexical_disambiguation(context, tokens)\n\n return tokens","def tokenize(self, texts: List[str]) -> List[Token]:\n raise NotImplementedError","def get_gene_tokens(self, classification: Classification) -> List[GeneToken]:\n return self.get_protein_gene_symbol_tokens(classification)","def _list_known_secret_tokens():\n global _secret_token_map\n\n keys = list(_secret_token_map.keys())\n keys.sort()\n\n ret = ''\n for key in keys:\n if ret != '':\n ret += ', '\n ret += \"'\" + key + \"'\"\n return ret","def tokenize(self):\n tokens = []\n while not self.eos():\n\n # Try to match a new token\n token = None\n candidates = [self.number, self.character_constant, self.string_constant,\n self.identifier, self.operator, self.punctuator]\n for f in candidates:\n col = self.pos\n try:\n self.whitespace()\n token = f()\n self.prev_white = False\n tokens.append(token)\n break\n except TokenError:\n self.pos = col\n\n # Only continue matching if a token was found\n if token is None:\n break\n\n self.whitespace()\n if not self.eos():\n raise TokenError(\"Encountered invalid token.\")\n\n return tokens","def _get_tokens(s: str) ->List[str]:\n return [] if not s else _normalize_text(s).split()","def list():","def list():","def getWordsList(self):\n return self.words","def list(self):\n return self.request(\"GET\")","def list(self) -> typing.List[str]:\n pass","def access_token(self):\n social_auth = self.social_auth.get()\n return social_auth.tokens","def token(self):\n print(\"getter of token called\")\n return self._token","def _get_all_possible_tokens_ahead(self, context):\n tokens = []\n if context.position < len(context.input_str):\n for terminal in self.grammar.terminals.values():\n try:\n tok = terminal.recognizer(context.input_str,\n context.position)\n except TypeError:\n tok = terminal.recognizer(context, context.input_str,\n context.position)\n additional_data = ()\n if type(tok) is tuple:\n tok, *additional_data = tok\n if tok:\n tokens.append(Token(terminal, tok, context.position,\n additional_data))\n return tokens","def _find_all_tokens(self) -> [str]:\n return re.findall(\"[a-zA-Z\\d]+\", self.soup.get_text(separator=\" \", strip=True))","def _get_all_possible_tokens_ahead(self, context):\n tokens = []\n if context.position < len(context.input_str):\n for terminal in self.grammar.terminals.values():\n try:\n tok = terminal.recognizer(context.input_str,\n context.position)\n except TypeError:\n tok = terminal.recognizer(context, context.input_str,\n context.position)\n additional_data = ()\n if type(tok) is tuple:\n tok, *additional_data = tok\n if tok:\n tokens.append(Token(terminal, tok, additional_data))\n return tokens","def getList(self):\n return self.sorted_list.getList()","def get_lists(self):\n return [{\"id\": lst[\"list_id\"], \"name\": lst[\"name\"]}\n for lst in List.objects(user_id=self.user_id, active=True)]","def multiword_tokens(self):\n return self._mwts","def control_bus_tokens(self):\n if self.lliagraph:\n return self.lliagraph.control_bus_tokens.items()\n else:\n return []","def _parse_individual_tokens(self, tokens: List[str]) -> List:\r\n objs = []\r\n\r\n for token in tokens:\r\n obj = self._parse_token(token)\r\n objs.append(obj)\r\n\r\n return objs","def get_tokens():\n return (AMS_MONITOR_PID_DIR,)"],"string":"[\n \"def get_tokens(self) -> List[str]:\\n return self.tokens\",\n \"def tokens(self):\\n # type: () -> List[Token]\\n return self._tokens\",\n \"def tokens(self):\\n return self.rpc.call(MsfRpcMethod.AuthTokenList)['tokens']\",\n \"def get_tokens(self):\\r\\n return self.token_set\",\n \"def get_token_list():\\n token_list = []\\n tokens_dir_path = os.path.join(BASE_DIR, TOKENS_DIR)\\n for dir, dirs, files in os.walk(tokens_dir_path):\\n for file_name in files:\\n file = open(os.path.join(tokens_dir_path, file_name), 'r')\\n token_list.append(file.read().strip())\\n file.close()\\n return token_list\",\n \"def getTokens(self):\\n return self.__token\",\n \"def tokens(self):\\n return self.__tokens\",\n \"def tokens(self):\\n return self._tokens\",\n \"def tokens(self):\\n return self._tokens\",\n \"def tokens(self):\\n return self._tokens\",\n \"def tokens(self) -> list:\\n if self._tokens is None:\\n tokens_ = sorted(list(self.elements()))\\n self._tokens = tokens_\\n return self._tokens\",\n \"def getTokens(self):\\n list = []\\n for i in range(self.startIdx, self.endIdx + 1):\\n token = self.sentence[i]\\n list.append(token)\\n return list\",\n \"def get_token_names(self) -> List[str]:\\n return list(self._tokens.keys())\",\n \"def get_tokens(self):\\r\\n return TokenGroup.get_tokens(self._tu, self.extent)\",\n \"def get_Tokens(self):\\n return self._output.get('Tokens', None)\",\n \"def get_token_list(text):\\n return text.split()\",\n \"def tokens():\\n return ['access token', 'refresh token']\",\n \"def all_tokens(self) -> List[Hashable]:\\n return self._all_tokens\",\n \"def list(uid: int):\\n\\n return Token.list(uid)\",\n \"def list_tokens(self) -> str:\\n\\n return self._format_symbol_table_content(\\\"Tokens\\\", self._symbols.keys())\",\n \"def get_tokens(self):\\n def _traverse_preorder(cursor, token_list): # There is a method called \\\"walk_preorder\\\" in Cursor class. Here we need to ignore some subtrees so we implement on our own.\\n if cursor.location.file and cursor.location.file.name != self.filepath: # exclude \\\"#include <...>\\\"\\n return\\n if (cursor.kind, cursor.spelling) in exclude_types: # exclude node in 'exclude_types'\\n return\\n \\n token_list.append(cursor)\\n for child in cursor.get_children():\\n _traverse_preorder(child, token_list)\\n\\n tokens = []\\n _traverse_preorder(self.cursor, tokens)\\n return tokens\",\n \"def getTokens(self):\\n self.__require_privilaged_access()\\n with DBSession(self.__config_db) as session:\\n user = self.getLoggedInUser()\\n sessionTokens = session.query(Session) \\\\\\n .filter(Session.user_name == user) \\\\\\n .filter(Session.can_expire.is_(False)) \\\\\\n .all()\\n\\n result = []\\n for t in sessionTokens:\\n result.append(SessionTokenData(\\n t.token,\\n t.description,\\n str(t.last_access)))\\n\\n return result\",\n \"def token_values(self):\\n return self._token_values\",\n \"def getTokens(self):\\n # NOTE: seems to be used by the evitaNominalTrainer only\\n tokenList = []\\n for chunkOrToken in self.dtrs:\\n if chunkOrToken.isToken():\\n tokenList += [chunkOrToken]\\n elif chunkOrToken.isChunk():\\n tokenList += chunkOrToken.dtrs\\n else:\\n logger.warn(\\\"Sentence element that is not a chunk or token\\\")\\n return tokenList\",\n \"def tokens(self):\\n tokens = []\\n for index in range(len(self.sentrep)):\\n tokens.append(self.sentrep.getWord(index).lexeme())\\n return tokens\",\n \"def tokens(self):\\r\\n return self.iter_tokens(self._blob)\",\n \"def get_tokens(self, document):\\n raise NotImplementedError()\",\n \"def get_tokens(self):\\n\\t\\treturn self.get_starttokens() + self.get_endtokens()\",\n \"def tokens(self):\\r\\n return Tokens(self)\",\n \"def __repr__(self) -> str:\\n return \\\"<Twilio.Oauth.V1.TokenList>\\\"\",\n \"def tokens(self):\\n return self._sentrep.tokens()\",\n \"def get_tokens(self, *args, **kwargs) -> List[Token]:\\n for text in args:\\n for char in text:\\n self.set_tokens(char)\\n self.flush_temp()\\n\\n return self.tokens\",\n \"def tokens(self):\\n\\t\\tlabels_and_synonyms = list(itertools.chain.from_iterable(list(self.term_to_tokens.values())))\\n\\t\\ttokens = set(list(itertools.chain.from_iterable([word_tokenize(x) for x in labels_and_synonyms])))\\n\\t\\treturn(list(tokens))\",\n \"def get_tokens():\\n return (HDFS_SITE_KEY, NAMESERVICE_KEY, NN_HTTP_ADDRESS_KEY, DFS_POLICY_KEY,\\n EXECUTABLE_SEARCH_PATHS, NN_HTTPS_ADDRESS_KEY, SMOKEUSER_KEY,\\n KERBEROS_KEYTAB, KERBEROS_PRINCIPAL, SECURITY_ENABLED_KEY,\\n METRICS_COLLECTOR_VIP_HOST_KEY, METRICS_COLLECTOR_VIP_PORT_KEY,\\n METRICS_COLLECTOR_WEBAPP_ADDRESS_KEY, AMS_HTTP_POLICY)\",\n \"def bearer_tokens(self):\\n return self._bearer_tokens\",\n \"def list_revoked_tokens(self):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def special_tokens(self) -> List[Hashable]:\\n return list(self._special_token_kv.values())\",\n \"def synth_tokens(self):\\n if self.lliagraph:\\n return self.lliagraph.synth_tokens.items()\\n else:\\n return []\",\n \"def getList(self):\\n pass\",\n \"def get_token_types() -> List[type]:\\n return ExtensionTokenTypes.__TOKEN_TYPES\",\n \"def getList(self):\\n\\treturn self.list\",\n \"def list_tokens(user):\\n return AppSpecificAuthToken.select().where(AppSpecificAuthToken.user == user)\",\n \"def getToken(self):\\n \\n raise NotImplementedError\",\n \"def getList(self):\",\n \"def getList(self):\",\n \"def get_read_tokens(mastertoken, config):\\n mt_path = mastertoken['paths']['self']\\n url = \\\"{}{}/read_tokens.json\\\".\\\\\\n format(config['domain_base'], mt_path)\\n\\n try:\\n resp = (api_call(url, 'get', config['debug']))\\n tokens = resp.json()\\n except ValueError as ex:\\n abort(\\\"Unexpected response from packagecloud API: \\\"\\n \\\"{}\\\".format(ex.message))\\n\\n return tokens['read_tokens']\",\n \"def tokens():\\n pass\",\n \"def get_list_of_tokens(self, to_lower=True, remove_newlines=True):\\n if not self.tokens:\\n assert self.url, \\\"Wrong url provided!\\\"\\n self.text = self._get_text(remove_newlines=remove_newlines)\\n self.log.debug(u\\\"First 100 characters of text from {url}: {text}\\\"\\n \\\"\\\".format(url=self.url,\\n text=self.text[:100]))\\n self.tokens = self._get_tokens()\\n self.log.debug(u\\\"First 100 tokens of text from {url}: {tokens}\\\"\\n \\\"\\\".format(url=self.url,\\n tokens=self.tokens))\\n if to_lower:\\n # all words to lowercase\\n self.tokens = list(map(lambda s: s.lower(), self.tokens))\\n return self.tokens\",\n \"def getList(self):\\n return self.list\",\n \"def tokens(self):\\n return tuple(self._tree.getWords())\",\n \"def tokenize(self):\\n tknzr = TweetTokenizer()\\n tkn = []\\n for tweet in self.tweets:\\n for word in tknzr.tokenize(tweet):\\n tkn.append(word)\\n return tkn\",\n \"def getList(self):\\n return self.list_\",\n \"def get_tokens(self, text):\\n if text is not None:\\n text = text.strip()\\n words = self.safe_split(text)\\n return words\\n return []\",\n \"def get(self, filters=None, pagination=None, sort=None):\\n filters = filters or {}\\n if not is_user_action_allowed('manage_others_tokens'):\\n filters['_user_fk'] = current_user.id\\n\\n sm = get_storage_manager()\\n\\n result = sm.list(models.Token, filters=filters,\\n pagination=pagination, sort=sort)\\n\\n return result\",\n \"def keys(self):\\n return list(self.token2id.values())\",\n \"def list(self):\\n return self._get_list()\",\n \"def parse(self) -> List[List[Union[str,int]]]:\\n return self.__create_list(cp(self.tokens))\",\n \"def get_tokens():\\n return (ZEPPELIN_USER_KEY, UI_SSL_ENABLED, SECURITY_ENABLED_KEY, ZEPPELIN_KEYTAB_KEY, ZEPPELIN_PRINCIPAL_KEY,\\n KERBEROS_EXECUTABLE_SEARCH_PATHS_KEY, ZEPPELIN_PORT_KEY, ZEPPELIN_PORT_SSL_KEY)\",\n \"def tokens(self):\\n tokens = [k for k in self.tok2ind.keys()\\n if k not in {'<NULL>', '<UNK>'}]\\n return tokens\",\n \"def word_list(self) -> List[str]:\\n return self._word_list\",\n \"def tokens_and_tags(self):\\n return list(zip(self.tokens(), self.tags()))\",\n \"def token_lookup():\\n token_list = {\\\".\\\": \\\"||Period||\\\",\\n \\\",\\\": \\\"||Comma||\\\",\\n '\\\"': \\\"|Quotation_Mark||\\\",\\n \\\";\\\": \\\"||Semicolon||\\\",\\n \\\"!\\\": \\\"||Exclamation_Mark||\\\",\\n \\\"?\\\": \\\"||Question_Mark||\\\",\\n \\\"(\\\": \\\"||Left_Parentheses||\\\",\\n \\\")\\\": \\\"||Right_Parentheses||\\\",\\n \\\"--\\\": \\\"||Dash||\\\",\\n \\\"\\\\n\\\": \\\"||Return||\\\"\\n }\\n\\n return token_list\",\n \"def get_read_tokens_dict(mastertoken, config):\\n token_list = {}\\n tokens = get_read_tokens(mastertoken, config)\\n\\n for token in tokens:\\n if token['name']:\\n token_list[token['name']] = token['value']\\n if config['debug']:\\n print(\\\"DEBUG: Found token {} with value {}\\\".\\n format(token['name'], token['value']))\\n\\n return token_list\",\n \"def get_commands_list() -> list:\\n return open(\\\"data/metadata/commands.list.txt\\\", \\\"r\\\").read().split(\\\"\\\\n\\\")\",\n \"def get_components(self):\\r\\n return [Token.from_multiword(word, index, self) for index, word in enumerate(self.wordform.split('_'))]\",\n \"def getTokens(username):\\n tokens = users.find({\\\"Username\\\": username})[0][\\\"Tokens\\\"]\\n return tokens\",\n \"def get_list(key):\\n ret = hookenv.action_get(key)\\n return ret.split() if ret else []\",\n \"def get_tokens(self, node, include_extra=False):\\n # type: (AstNode, bool) -> Iterator[Token]\\n return self.token_range(node.first_token, node.last_token, include_extra=include_extra)\",\n \"def importantTokenList(self, ignoreSemanticTagList=[]):\\n list = tokenlist.TokenList()\\n for token in self.tokens:\\n if token.isAcronym():\\n expansion = token.getAcronymExpansion()\\n \\n# print token.text, '=', \\n# for t in expansion:\\n# print t.text,\\n# print\\n\\n# list.append(token)\\n# for t in token.getAcronymExpansion():\\n# if self.isImportantToken(t):\\n# list.append(t)\\n\\n if expansion == None or len(expansion) == 0:\\n list.append(token)\\n else:\\n for t in token.getAcronymExpansion():\\n if self.isImportantToken(t, ignoreSemanticTagList=ignoreSemanticTagList):\\n list.append(t)\\n elif self.isImportantToken(token, ignoreSemanticTagList=ignoreSemanticTagList):\\n list.append(token)\\n \\n return list\",\n \"def __create_list(self, tokens : List[Union[str,int]]) -> List[List[Union[str,int]]]:\\n if tokens:\\n return [self.__add_instruction(cp(tokens[:1+syntaxParametersDict.get(tokens[0])]))] + self.__create_list(cp(tokens[1+syntaxParametersDict.get(tokens[0]):]))\\n return []\",\n \"def get_symbols_list(self):\\n return self.symbols_list\",\n \"def tokenize(cls, selector):\\n\\n cls.lexer.input(selector)\\n token_list = []\\n while True:\\n token = cls.lexer.token()\\n if not token: break\\n token_list.append(token)\\n return token_list\",\n \"def _list_tokens(self, user_id, tenant_id=None, trust_id=None,\\n consumer_id=None):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def listTags(self, authenticationToken):\\r\\n pass\",\n \"def tokens(self):\\n data, end = \\\\\\n self.pat.traverse(lambda obj, *args: obj.tokens(*args),\\n self.begin, self.data)\\n return data\",\n \"def get_nft_list(self):\\n tokens = self.api.find_all(\\\"nft\\\", \\\"nfts\\\", query={})\\n return tokens\",\n \"def parse_token_list(data):\\n\\n state = http_header_util.ParsingState(data)\\n\\n token_list = []\\n\\n while True:\\n token = http_header_util.consume_token(state)\\n if token is not None:\\n token_list.append(token)\\n\\n http_header_util.consume_lwses(state)\\n\\n if http_header_util.peek(state) is None:\\n break\\n\\n if not http_header_util.consume_string(state, ','):\\n raise HandshakeException(\\n 'Expected a comma but found %r' % http_header_util.peek(state))\\n\\n http_header_util.consume_lwses(state)\\n\\n if len(token_list) == 0:\\n raise HandshakeException('No valid token found')\\n\\n return token_list\",\n \"def _next_tokens(self, head):\\n state = head.state\\n input_str = self.input_str\\n position = head.position\\n actions = state.actions\\n in_len = len(input_str)\\n tokens = []\\n\\n # add special STOP token if they are applicable\\n if STOP in actions:\\n if not self.consume_input \\\\\\n or (self.consume_input and position == in_len):\\n tokens.append(STOP_token)\\n\\n if position < in_len:\\n # Get tokens by trying recognizers - but only if we are not at\\n # the end, because token cannot be empty\\n if self.custom_token_recognition:\\n def get_tokens():\\n return self._token_recognition(head)\\n\\n custom_tokens = self.custom_token_recognition(\\n head, get_tokens,\\n )\\n if custom_tokens is not None:\\n tokens.extend(custom_tokens)\\n else:\\n tokens.extend(self._token_recognition(head))\\n\\n # do lexical disambiguation if it is enabled\\n if self.lexical_disambiguation:\\n tokens = self._lexical_disambiguation(tokens)\\n\\n return tokens\",\n \"def getList(self):\\n\\treturn self.sorted_list.getList()\",\n \"def _next_tokens(self, context):\\n state = context.state\\n input_str = context.input_str\\n position = context.position\\n actions = state.actions\\n in_len = len(input_str)\\n tokens = []\\n\\n # add special tokens (EMPTY and STOP) if they are applicable\\n if EMPTY in actions:\\n tokens.append(EMPTY_token)\\n if STOP in actions:\\n if not self.consume_input \\\\\\n or (self.consume_input and position == in_len):\\n tokens.append(STOP_token)\\n\\n if position < in_len:\\n # Get tokens by trying recognizers - but only if we are not at\\n # the end, because token cannot be empty\\n if self.custom_token_recognition:\\n def get_tokens():\\n return self._token_recognition(context)\\n\\n custom_tokens = self.custom_token_recognition(\\n context, get_tokens,\\n )\\n if custom_tokens is not None:\\n tokens.extend(custom_tokens)\\n else:\\n tokens.extend(self._token_recognition(context))\\n\\n # do lexical disambiguation if it is enabled\\n if self.lexical_disambiguation:\\n tokens = self._lexical_disambiguation(context, tokens)\\n\\n return tokens\",\n \"def tokenize(self, texts: List[str]) -> List[Token]:\\n raise NotImplementedError\",\n \"def get_gene_tokens(self, classification: Classification) -> List[GeneToken]:\\n return self.get_protein_gene_symbol_tokens(classification)\",\n \"def _list_known_secret_tokens():\\n global _secret_token_map\\n\\n keys = list(_secret_token_map.keys())\\n keys.sort()\\n\\n ret = ''\\n for key in keys:\\n if ret != '':\\n ret += ', '\\n ret += \\\"'\\\" + key + \\\"'\\\"\\n return ret\",\n \"def tokenize(self):\\n tokens = []\\n while not self.eos():\\n\\n # Try to match a new token\\n token = None\\n candidates = [self.number, self.character_constant, self.string_constant,\\n self.identifier, self.operator, self.punctuator]\\n for f in candidates:\\n col = self.pos\\n try:\\n self.whitespace()\\n token = f()\\n self.prev_white = False\\n tokens.append(token)\\n break\\n except TokenError:\\n self.pos = col\\n\\n # Only continue matching if a token was found\\n if token is None:\\n break\\n\\n self.whitespace()\\n if not self.eos():\\n raise TokenError(\\\"Encountered invalid token.\\\")\\n\\n return tokens\",\n \"def _get_tokens(s: str) ->List[str]:\\n return [] if not s else _normalize_text(s).split()\",\n \"def list():\",\n \"def list():\",\n \"def getWordsList(self):\\n return self.words\",\n \"def list(self):\\n return self.request(\\\"GET\\\")\",\n \"def list(self) -> typing.List[str]:\\n pass\",\n \"def access_token(self):\\n social_auth = self.social_auth.get()\\n return social_auth.tokens\",\n \"def token(self):\\n print(\\\"getter of token called\\\")\\n return self._token\",\n \"def _get_all_possible_tokens_ahead(self, context):\\n tokens = []\\n if context.position < len(context.input_str):\\n for terminal in self.grammar.terminals.values():\\n try:\\n tok = terminal.recognizer(context.input_str,\\n context.position)\\n except TypeError:\\n tok = terminal.recognizer(context, context.input_str,\\n context.position)\\n additional_data = ()\\n if type(tok) is tuple:\\n tok, *additional_data = tok\\n if tok:\\n tokens.append(Token(terminal, tok, context.position,\\n additional_data))\\n return tokens\",\n \"def _find_all_tokens(self) -> [str]:\\n return re.findall(\\\"[a-zA-Z\\\\d]+\\\", self.soup.get_text(separator=\\\" \\\", strip=True))\",\n \"def _get_all_possible_tokens_ahead(self, context):\\n tokens = []\\n if context.position < len(context.input_str):\\n for terminal in self.grammar.terminals.values():\\n try:\\n tok = terminal.recognizer(context.input_str,\\n context.position)\\n except TypeError:\\n tok = terminal.recognizer(context, context.input_str,\\n context.position)\\n additional_data = ()\\n if type(tok) is tuple:\\n tok, *additional_data = tok\\n if tok:\\n tokens.append(Token(terminal, tok, additional_data))\\n return tokens\",\n \"def getList(self):\\n return self.sorted_list.getList()\",\n \"def get_lists(self):\\n return [{\\\"id\\\": lst[\\\"list_id\\\"], \\\"name\\\": lst[\\\"name\\\"]}\\n for lst in List.objects(user_id=self.user_id, active=True)]\",\n \"def multiword_tokens(self):\\n return self._mwts\",\n \"def control_bus_tokens(self):\\n if self.lliagraph:\\n return self.lliagraph.control_bus_tokens.items()\\n else:\\n return []\",\n \"def _parse_individual_tokens(self, tokens: List[str]) -> List:\\r\\n objs = []\\r\\n\\r\\n for token in tokens:\\r\\n obj = self._parse_token(token)\\r\\n objs.append(obj)\\r\\n\\r\\n return objs\",\n \"def get_tokens():\\n return (AMS_MONITOR_PID_DIR,)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83647424","0.80425704","0.79461306","0.79414326","0.78283435","0.75734204","0.75067395","0.7500921","0.7500921","0.7500921","0.74711776","0.74703306","0.73524517","0.72486407","0.7219096","0.7147502","0.7132472","0.7059246","0.6929604","0.69008","0.68774545","0.686128","0.68404263","0.6840318","0.6819085","0.67348593","0.6730855","0.67276204","0.66702497","0.66494155","0.6629424","0.6583703","0.6573836","0.6543659","0.6498906","0.6485851","0.6470962","0.6457","0.64515626","0.6442808","0.6425382","0.63887453","0.6386064","0.6385717","0.6385717","0.6379771","0.6358245","0.63545257","0.63518584","0.63429683","0.63183314","0.6314165","0.6299709","0.62857884","0.62638175","0.62050277","0.61972135","0.61802936","0.6138678","0.61276966","0.6107711","0.60978097","0.6094398","0.6072132","0.60652035","0.6059414","0.60503453","0.6047183","0.6046054","0.60413086","0.60388184","0.6032984","0.6025284","0.60188574","0.60180384","0.60169125","0.5992728","0.5977007","0.5970087","0.5955897","0.59460896","0.59249353","0.59140575","0.58983827","0.58982646","0.58917004","0.58917004","0.5873252","0.5866376","0.58663315","0.5858681","0.5853012","0.5843518","0.58341515","0.58270955","0.58259135","0.5824618","0.5824196","0.5820515","0.58200955","0.5818195"],"string":"[\n \"0.83647424\",\n \"0.80425704\",\n \"0.79461306\",\n \"0.79414326\",\n \"0.78283435\",\n \"0.75734204\",\n \"0.75067395\",\n \"0.7500921\",\n \"0.7500921\",\n \"0.7500921\",\n \"0.74711776\",\n \"0.74703306\",\n \"0.73524517\",\n \"0.72486407\",\n \"0.7219096\",\n \"0.7147502\",\n \"0.7132472\",\n \"0.7059246\",\n \"0.6929604\",\n \"0.69008\",\n \"0.68774545\",\n \"0.686128\",\n \"0.68404263\",\n \"0.6840318\",\n \"0.6819085\",\n \"0.67348593\",\n \"0.6730855\",\n \"0.67276204\",\n \"0.66702497\",\n \"0.66494155\",\n \"0.6629424\",\n \"0.6583703\",\n \"0.6573836\",\n \"0.6543659\",\n \"0.6498906\",\n \"0.6485851\",\n \"0.6470962\",\n \"0.6457\",\n \"0.64515626\",\n \"0.6442808\",\n \"0.6425382\",\n \"0.63887453\",\n \"0.6386064\",\n \"0.6385717\",\n \"0.6385717\",\n \"0.6379771\",\n \"0.6358245\",\n \"0.63545257\",\n \"0.63518584\",\n \"0.63429683\",\n \"0.63183314\",\n \"0.6314165\",\n \"0.6299709\",\n \"0.62857884\",\n \"0.62638175\",\n \"0.62050277\",\n \"0.61972135\",\n \"0.61802936\",\n \"0.6138678\",\n \"0.61276966\",\n \"0.6107711\",\n \"0.60978097\",\n \"0.6094398\",\n \"0.6072132\",\n \"0.60652035\",\n \"0.6059414\",\n \"0.60503453\",\n \"0.6047183\",\n \"0.6046054\",\n \"0.60413086\",\n \"0.60388184\",\n \"0.6032984\",\n \"0.6025284\",\n \"0.60188574\",\n \"0.60180384\",\n \"0.60169125\",\n \"0.5992728\",\n \"0.5977007\",\n \"0.5970087\",\n \"0.5955897\",\n \"0.59460896\",\n \"0.59249353\",\n \"0.59140575\",\n \"0.58983827\",\n \"0.58982646\",\n \"0.58917004\",\n \"0.58917004\",\n \"0.5873252\",\n \"0.5866376\",\n \"0.58663315\",\n \"0.5858681\",\n \"0.5853012\",\n \"0.5843518\",\n \"0.58341515\",\n \"0.58270955\",\n \"0.58259135\",\n \"0.5824618\",\n \"0.5824196\",\n \"0.5820515\",\n \"0.58200955\",\n \"0.5818195\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7386,"cells":{"query":{"kind":"string","value":"Convert `document` into the bagofwords (BoW) format = list of `(token_id, token_count)` tuples."},"document":{"kind":"string","value":"def doc2bow(self, document, allow_update=False, return_missing=False):\n\n doc=[t.text for t in document.tokens]\n\n if isinstance(doc, string_types):\n raise TypeError(\"doc2bow expects an array of unicode tokens on input, not a single string\")\n\n # Construct (word, frequency) mapping.\n counter = defaultdict(int)\n for w in doc:\n counter[w if isinstance(w, str) else str(w, 'utf-8')] += 1\n\n token2id = self.token2id\n if allow_update or return_missing:\n missing = sorted(x for x in iteritems(counter) if x[0] not in token2id)\n if allow_update:\n for w, _ in missing:\n # new id = number of ids made so far;\n # NOTE this assumes there are no gaps in the id sequence!\n token2id[w] = len(token2id)\n result = {token2id[w]: freq for w, freq in iteritems(counter) if w in token2id}\n\n if allow_update:\n self.num_docs += 1\n self.num_pos += sum(itervalues(counter))\n self.num_nnz += len(result)\n # keep track of document and collection frequencies\n for tokenid, freq in iteritems(result):\n self.cfs[tokenid] = self.cfs.get(tokenid, 0) + freq\n self.dfs[tokenid] = self.dfs.get(tokenid, 0) + 1\n\n # return tokenids, in ascending id order\n result = sorted(iteritems(result))\n if return_missing:\n return result, dict(missing)\n else:\n return result"},"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 make_bag_words(document_tokenized):\n bag_words = dict()\n for token in document_tokenized:\n if token in bag_words.keys():\n bag_words[token] += 1\n else:\n bag_words[token] = 1\n return bag_words","def sentencesToBow(documents):\n bowSentences = []\n dictionary = Dictionary(documents)\n\n numDocs = len(documents);\n avgDocLength = sum(map(len, documents))/numDocs\n for document in documents:\n bowSentence = []\n docLength = len(document)\n bowDoc = dictionary.doc2bow(document)\n for bowTerm in bowDoc:\n\n docTermFreq = bowTerm[1]\n termDocFreq = dictionary.dfs[bowTerm[0]]\n\n termWeight = docTermWeight(docTermFreq, termDocFreq, docLength, avgDocLength, numDocs, k=5, b=0.1)\n newBowTerm = (bowTerm[0], termWeight)\n bowSentence.append(newBowTerm)\n\n bowSentences.append(bowSentence)\n\n return bowSentences, dictionary","def word_frequency(self, document):\n freq_table = {}\n words = nltk.word_tokenize(document)\n for word in words:\n if word in freq_table:\n freq_table[word] = freq_table.get(word) + 1\n else:\n freq_table[word] = 1\n # cut down the frequency table so that only common words are scored for\n freq_table = sorted(freq_table.items(), key=lambda x: x[1], reverse=True)\n scorable_words = []\n for word, occ in freq_table:\n # set threshold as words appearing x times or more - set to optimal valeue = 0\n # in hindsight this can just be deleted\n if int(occ) > 0:\n scorable_words.append(word)\n else:\n break\n self.sent_pos = self.sent_pos + 1 \n return scorable_words","def gen_bag_of_words_df(self):\n\t\tdef word_vector(doc_text):\n\t\t\tfreqs = pd.Series(collections.Counter(doc_text.split()))\n\t\t\treturn freqs.loc[set(freqs.index.values)|set(self.stems)]\n\t\tself.bagofwords = self.dataframe.text.apply(word_vector).replace({np.nan:0})","def bow_vec(doc):\n return CECTORIZER.transform([doc]).toarray()","def bag_of_words(tokenized_sentence, all_words):\n\n tokenized_sentence = [stem(w) for w in tokenized_sentence]\n #print(tokenized_sentence)\n bag = np.zeros_like(all_words, dtype=np.float32)\n for idx, w in enumerate(all_words):\n if w in tokenized_sentence:\n bag[idx] = 1.0\n\n return bag","def add_doc(self, document):\n # Split document up into list of strings\n #words = self.tokenize(document)\n words = document\n # Count word frequencies in this document\n word_counts = {}\n for word in words:\n word_counts[word] = word_counts.get(word, 0) + 1\n # Add word counts as new row to sparse matrix\n self.sparse.append(word_counts)\n # Add to total document count for each word\n for word in word_counts:\n self.doc_count[word] = self.doc_count.get(word, 0) + 1","def tokenize(document):\n token = nltk.word_tokenize(document)\n\n output = [word.lower() for word in token if (word not in string.punctuation and word not in nltk.corpus.stopwords.words(\"english\"))]\n\n return output","def bow(tokens):\n return dict(collections.Counter(re.findall(r'\\w+', \" \".join(tokens))))","def tokenize(document):\n\n # Unable to acquire 'stopwords' without these snippets due to my python config\n # import ssl\n # ssl._create_default_https_context = ssl._create_unverified_context\n # nltk.download('stopwords')\n\n stops = nltk.corpus.stopwords.words(\"english\")\n\n all_words = list()\n cleaned_words = list()\n\n all_words = nltk.word_tokenize(document)\n\n for word in all_words:\n word = word.strip()\n word = word.lower()\n\n if word in stops \\\n or not word \\\n or word in string.punctuation \\\n or word.strip(\"=\") != word:\n continue\n else:\n cleaned_words.append(word)\n\n return cleaned_words","def featurize(self, data):\n \n bag_of_words = []\n\n tokens = data.split()\n\n for i in tokens:\n bag_of_words.append((i, True))\n\n return bag_of_words","def preproc_doc(document):\n tokenizer = tokenization.FullTokenizer(\n vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)\n\n # document = [\n # tokenization.convert_to_unicode(\n # unidecode.unidecode(line.decode(\"utf-8\"))) for line in document\n # ]\n\n sent_tokens = [tokenizer.tokenize(sent) for sent in document if sent]\n sent_tokens = [sent for sent in sent_tokens if len(sent) > 1]\n if len(sent_tokens) < 8:\n return []\n\n # Convert token lists into ids and add any needed tokens and padding for BERT\n tf_example = convert_instance_to_tf_example(tokenizer, sent_tokens,\n FLAGS.max_sent_length,\n FLAGS.max_para_length)\n\n # Serialize TFExample for writing to file.\n tf_examples = [tf_example.SerializeToString()]\n\n return tf_examples","def bagOfWords(self):\n if self._bow is None:\n self._bow = {}\n for word in self._words:\n if word['word'] in self._bow:\n self._bow[word['word']] += 1\n else:\n self._bow[word['word']] = 1\n return self._bow","def get_tokenizer_result(blob):\n return list(blob.words)","def gen_words(self, doc):\n pattern = re.compile(u'[\\\\s\\\\d,.<>/?:;\\'\\\"[\\\\]{}()\\\\|~!@#$%^&*\\\\-_=+a-zA-Z，。《》、？：；“”‘’｛｝【】（）…￥！—┄－]+')\n doc = re.sub(pattern, ' ', doc)\n suffix_indexes = index_of_sorted_suffix(doc, self.max_word_len)\n word_cands = {}\n # compute frequency and neighbors\n for suf in suffix_indexes:\n word = doc[suf[0]:suf[1]]\n if word not in word_cands:\n word_cands[word] = WordInfo(word)\n word_cands[word].update(doc[suf[0] - 1:suf[0]], doc[suf[1]:suf[1] + 1])\n # compute probability and entropy\n length = len(doc)\n for k in word_cands:\n word_cands[k].compute(length)\n word_cands[k].compute_pp(self.pos_prop)\n # compute aggregation of words whose length > 1\n values = sorted(word_cands.values(), key=lambda x: len(x.text))\n for v in values:\n if len(v.text) == 1:\n continue\n v.compute_cohesion(word_cands)\n\n return sorted(values, key=lambda v: v.freq, reverse=True)","def tokenize(document):\n words = [word.lower() for word in nltk.word_tokenize(document) if word not in string.punctuation and word not in nltk.corpus.stopwords.words(\"english\") ]\n\n return sorted(words)","def convert_word_to_count(counter={}, doc=[]):\n for sentence in doc:\n for word in sentence.split():\n if word not in counter:\n counter[word] = 1\n else:\n counter[word] += 1\n return counter","def make_word_to_freq(self):\n\t\tword_to_freq = {}\n\t\tdocuments = self.tokenized_documents[\"train\"]\n\t\tfor document in documents:\n\t\t\tfor word in document:\n\t\t\t\tif not word in self.worddict: # make sure we have not found one of the pre-defined words\n\t\t\t\t\tword_to_freq[word] = word_to_freq.get(word, 0) + 1\n\t\t\n\t\treturn word_to_freq","def tokenize(document):\n\n # Initialize the list of words, punctuation and stopwords\n keywords = []\n punctuations_list = string.punctuation\n stopwords_list = nltk.corpus.stopwords.words(\"english\")\n\n # Make a naive tokenized copy of the `document`\n naive_list = nltk.word_tokenize(document)\n\n for item in naive_list:\n\n # Ignore punctuations or stopwords\n if (item in punctuations_list) or (item in stopwords_list) or (len(item) < 4):\n continue\n\n # Add document by coverting all words to lowercase\n keywords.append(item.lower())\n\n return keywords","def freq(word, document):\n return document.split(None).count(word)","def getReviewsWithToken(self, token):\n\n wordid = self.find_word_in_dictionary(token)\n # word is not in the dictionary\n if wordid == -1:\n print(\"Token is not in the dictionary\")\n return 0\n\n with open(self.doc_to_words_path, 'rb') as bin:\n tup = []\n while bin.tell() != os.fstat(bin.fileno()).st_size:\n # get wordid:\n docid_in_file = int.from_bytes(bin.read(4), 'big')\n # get frequency:\n frequency = int.from_bytes(bin.read(4), 'big')\n # count words:\n count = 0\n for i in range(frequency):\n wordid_in_file = int.from_bytes(bin.read(4), 'big')\n if wordid == wordid_in_file:\n count += 1\n tup.append(docid_in_file)\n tup.append(count)\n return tuple(tup)","def bagOfWords(self,phrase):\n return self._support.bagOfWords(phrase)","def get_vocab(self):\n word2id = {}\n for document in self.docs:\n for word in document:\n if word not in word2id.keys():\n word2id[word] = len(word2id)\n return word2id","def get_doc(corpus):\n doc_info = []\n\n for idx, text in enumerate(corpus):\n count = len(word_tokenize(text))\n doc_info.append({'doc_length': count})\n\n return doc_info","def vectorize_doc(document):\n # return document vector for tokenized input doc\n return bc.encode([document])[0]","def tokenize(document):\n import string\n\n # tokenize the given document\n words = nltk.tokenize.word_tokenize(document)\n words = [word.lower() for word in words]\n\n # filter words from punctuations and stopwords\n loop_words = words.copy()\n for word in loop_words:\n if word in [char for char in string.punctuation] + nltk.corpus.stopwords.words(\"english\"):\n words.remove(word)\n\n return words","def vocabulary(corpus_tokenized):\n vocab = list()\n for element in corpus_tokenized:\n document = element['document']\n for word in document:\n if word not in vocab:\n vocab.append(word)\n return vocab","def num_bigram(doc):\n matched_spans = []\n matches = matcher(doc)\n for match_id, start, end in matches:\n span = doc[start:end]\n matched_spans.append(span)\n for span in matched_spans: # merge into one token after collecting all matches\n span.merge()\n return doc","def doc2vec(self, doc):\n contained_words = self.cut_words(doc)\n vec = []\n for wrd in self.words:\n tf = contained_words.count(wrd) / len(contained_words)\n df = self.dfdict[wrd] + 1\n if wrd in contained_words: df += 1\n idf = log10((len(self.docs) + 1) / df)\n vec.append(tf * idf)\n return vec","def wordCount(document):\n return float(len(document.split(None)))","def corpus2mallet(self, corpus, file_like):\n for docno, doc in enumerate(corpus):\n if self.id2word:\n tokens = chain.from_iterable([self.id2word[tokenid]] * int(cnt) for tokenid, cnt in doc)\n else:\n tokens = chain.from_iterable([str(tokenid)] * int(cnt) for tokenid, cnt in doc)\n file_like.write(utils.to_utf8(\"%s 0 %s\\n\" % (docno, ' '.join(tokens))))","def tokenize_into_words(myblob):\n set_constraint = re.compile(r'[^a-zA-Z0-9]')\n tokenize_to_text = set_constraint.split(myblob) # The blob is spilt into words and the given constraints are applied\n words = [word for word in tokenize_to_text if word]\n return words","def tokenize_and_split_bis(sms_file):\n \n dic = {}\n list1 = []\n list2 = []\n list3 = []\n list4 = []\n i = -1\n document = 0\n terms = 0\n new_document = True\n ham = True\n for line in open(sms_file, 'r').readlines():\n w = []\n document += 1\n new_document = True\n for word in line.split():\n i = i + 1\n if word == \"ham\":\n ham = True\n i = i - 1\n elif word == \"spam\":\n ham = False\n i = i - 1\n else:\n if word not in dic:\n dic[word] = i\n w.append(dic[word])\n list3.append(1)\n list4.append(1)\n new_document = False\n terms += 1\n else : \n i = i - 1\n w.append(dic[word])\n list4[dic[word]] += 1\n terms += 1\n if new_document: \n list3[dic[word]] += 1\n new_document = False\n \n if ham and w !=[]:\n list2.append(w)\n elif ham == False and w !=[]:\n list1.append(w)\n\n moy = 0\n len_dic = len(dic.keys())\n list5 = [0 for x in range(len_dic)]\n for key in dic.keys():\n if list4[dic[key]] > 0:\n tf = list4[dic[key]] / terms\n idf = math.log(document / list3[dic[key]])\n tfIdf = tf * idf\n list5[dic[key]] = tfIdf\n # print(\"the word \" + str(key) + \" appairs \" + str(list4[dic[key]]) + \" times.\")\n # print(\"his frequency is \" + str(list4[dic[key]] / terms) )\n # print(\"the word \" + str(key) + \" appairs \" + str(list3[dic[key]]) + \" times in each document.\")\n # print(\"his frequency is \" + str(idf))\n # print(\"utility \" + str(tfIdf))\n moy += tfIdf\n \n moy = moy / len_dic \n # print(moy)\n dic_bis = {}\n i = -1\n for key in dic.keys():\n value = list5[dic[key]]\n # print(str(value))\n if (value > oracle * moy):\n i += 1\n dic_bis[key] = i\n # else:\n # print(\"not pass \" + key + \" \" + str(value))\n \n \n # print(dic_bis == dic)\n # print(dic)\n return dic_bis,list1,list2","def bag_of_words(batch, TEXT):\n V = len(TEXT.vocab)\n X = torch.zeros(batch.text.size(0), V)\n ones = torch.ones(batch.text.size(1))\n for b in range(batch.text.size(0)):\n X[b].index_add_(0, batch.text.data[b], ones)\n X[b][TEXT.vocab.stoi['<pad>']] = 0\n X = Variable(X, requires_grad=False)\n return X","def extract_terms(document):\n tokens = word_tokenize(document)\n stemmer = PorterStemmer()\n terms = {} # Dictionary {term: appearances}\n word_count = 0 # To return total (meaningful) word count\n for token in tokens:\n token = token.lower() # Lowercase\n token = token.strip(string.punctuation) # Remove punctuation\n if token and token not in stopwords.words(\"english\"): # Remove stopwords\n token = stemmer.stem(token) # Using Porter Stemmer\n if token not in terms:\n terms[token] = 1\n else:\n terms[token] += 1\n word_count += 1\n return terms, word_count","def get_words_with_nplus_frequency(tokenized_sentences, count_threshold):\r\n\r\n closed_vocab = []\r\n \r\n\r\n word_counts = count_words(tokenized_sentences)\r\n \r\n\r\n for word, cnt in word_counts.items(): # complete this line\r\n \r\n\r\n if cnt >= count_threshold:\r\n \r\n # append the word to the list\r\n closed_vocab.append(word)\r\n \r\n return closed_vocab","def tokenize(document):\n words = nltk.word_tokenize(document)\n # tokenize files into a list of words\n return [\n word.lower() for word in words\n # filter out all punctuation (import string) and all stopwords\n if not all(char in string.punctuation for char in word) \n and word not in nltk.corpus.stopwords.words(\"english\")\n ]","def bag_of_features(self, word, normalize=True):\n word_features = self.word_fts(word, normalize)\n features = [v + f for f in self.names for v in ['+', '0', '-']]\n bag = collections.OrderedDict()\n for f in features:\n bag[f] = 0\n vdict = {-1: '-', 0: '0', 1: '+'}\n for w in word_features:\n for (f, v) in w.items():\n bag[vdict[v] + f] += 1\n return numpy.array(list(bag.values()))","def word_count(self, document):\n start_time = time.time()\n dictionary = dict()\n counter = defaultdict(int)\n for line in document.splitlines():\n for word in line.split():\n if word not in PUNCTUATION_MARK:\n counter[word] += 1\n for word, cnt in sorted(counter.items(), key=lambda x: (-x[1], x[0])):\n dictionary[word] = cnt\n self.log.info(\"Duration count dictionary: {duration}\".format(duration=float(time.time() - start_time)))\n return dictionary","def countFreq(self,document):\n self.document = document\n vocab=['python','js','android','php','django','javascript','oracle','ruby','rails','java']\n cnt_vector = CountVectorizer(vocabulary=vocab)\n self.freq_term_matrix = cnt_vector.fit_transform(self.document)\n return self.freq_term_matrix.toarray()","def tokenize(document):\n raw_words=[word.lower() for word in nltk.word_tokenize(document) if word.isalpha()]\n raw_words=[word.lower() for word in raw_words]\n final_words=[]\n for word in raw_words:\n if word not in string.punctuation and word not in nltk.corpus.stopwords.words(\"english\"):\n final_words.append(word.lower())\n return final_words","def word_frequency(book):\n unique_dict = unique_words(book)\n\n word_array = pd.DataFrame(list(unique_dict.items()), columns=['Word', 'Occurence'])\n\n return word_array","def document_to_lda_features(lda_model, document):\n topic_importances = lda_model.get_document_topics(document, minimum_probability=0)\n topic_importances = numpy.array(topic_importances)\n return topic_importances[:,1]","def parse_doc(doc,vocab):\n doc=doc.lower()\n doc=re.sub(r'-',' ',doc)\n doc=re.sub(r' +',' ',doc) # turn multiple spaces into a single space\n doc=re.sub(r'[^a-z ]','',doc) # remove anything that is not a-z or space\n words=doc.split()\n word_vocab=[vocab.get(word,-1) for word in words]\n words_dict=collections.Counter(word_vocab)\n del words_dict[-1] # ignore the words outside the vocabulary\n #wordid=words_dict.keys()\n #wordcnt=words_dict.values()\n return sorted(words_dict.items())","def extract(self, document):\n f_num = len(self.feature_list)\n feature_vector = np.zeros((f_num,))\n words = document.split()\n for i in xrange(len(words)):\n for n in self.ns:\n ngram = self.try_get_ngram(words, n, i)\n if ngram and ngram in self.ngrams:\n self.add_ngram(feature_vector, ngram)\n return feature_vector","def tokenize(document):\n nltk.download('punkt')\n nltk.download('stopwords')\n wordList = nltk.word_tokenize(document.lower())\n punctuation = string.punctuation\n stopWords = nltk.corpus.stopwords.words(\"english\")\n listCopy = copy.deepcopy(wordList)\n for w in listCopy:\n if w in stopWords or w in punctuation:\n newList = list(filter(w.__ne__, wordList))\n wordList = newList\n return wordList","def count_words_sents(self, doc_array):\n total_num_sents = []\n total_num_words = []\n for doc in doc_array:\n sents = sent_tokenize(doc)\n total_num_sents.append(len(sents))\n temp_num_words = []\n for sent in sents:\n num_words = word_tokenize(sent)\n temp_num_words.append(len(num_words))\n total_num_words.append(temp_num_words)\n return np.array(total_num_sents), np.array(total_num_words)","def bag_of_words_model(features, target):\n target = tf.one_hot(target, 2, 1, 0)\n features = tf.contrib.layers.bow_encoder(\n features, vocab_size=n_words, embed_dim=Embedding_size, scope=\"input_layer\")\n hidden_layer1 = tf.contrib.layers.fully_connected(features, 100, scope=\"hidden_layer1\")\n logits = tf.contrib.layers.fully_connected(hidden_layer1, 2, scope=\"output_layer\",\n activation_fn=None)\n loss = tf.contrib.losses.softmax_cross_entropy(logits, target)\n train_op = tf.contrib.layers.optimize_loss(\n loss, tf.contrib.framework.get_global_step(),\n optimizer='Adam', learning_rate=0.01)\n return (\n {'class': tf.argmax(logits, 1),\n 'prob': tf.nn.softmax(logits)},\n loss, train_op)","def get_vocabulary(documents):\n cv_model = CountVectorizer(binary=True)\n cv_model.fit(documents)\n\n vocabulary = cv_model.get_feature_names()\n vocabulary = list(map(str, vocabulary))\n\n return vocabulary","def get_word_frequency(self, word, document):\n return self.dictionary[word]['docs'][document]","def get_number_of_words_in_document(self, document):\n for _set in self.sets:\n if document in _set:\n return self.sets[_set][document]['number_of_words']","def tfidf_bow(doc):\n\n if VECTORIZER == None:\n sys.stderr.write(\"ERROR: Vectorizer not defined... Did you call set_vocab?\\n\")\n return None\n return VECTORIZER.transform([doc]).toarray()","def lookup_bm25(self) -> list:\n prox_by_doc = {}\n for token in self._tokenizer.tokenize(self._query):\n for token_info in self._index.get_token_search(token):\n doc = token_info.doc\n if doc not in prox_by_doc:\n prox_by_doc[doc] = 0\n prox_by_doc[doc] += token_info.weight\n\n return sorted(prox_by_doc.items(), key=lambda t: t[1], reverse=True)","def doc2features(self,sent):\n return [self.word2features(sent['tokens'], i) for i in range(len(sent['tokens']))]","def word_occurrences(corpus):\n occur_array = []\n\n for e in corpus:\n occur = Counter(e)\n occur_array.append(occur)\n\n return occur_array","def mapWordsFrequencies(self):\n token_stream = self._tokenize(self.readable)\n token_map = self._countTokens(token_stream)\n return token_map","def create_bow(vocab, filepath):\n bow = {}\n # TODO: add your code here\n wordcount = 0\n wordcountnone = 0\n c = 0\n\n for i in vocab:\n c+=1\n with open(filepath, 'r', encoding=\"utf-8\") as doc: ###############################################\n for word in doc:\n word = word.strip()\n if(c==1):\n if (word not in vocab):\n wordcountnone += 1\n if(i == str(word)):\n wordcount += 1\n #print(wordcount)\n if(wordcount > 0):\n bow[i] = wordcount\n wordcount = 0\n if(wordcountnone != 0):\n bow[None] = wordcountnone\n return bow","def compute_tf(document):\r\n _len = len(document)\r\n tf_dict = {}\r\n for token in document:\r\n tf_dict.setdefault(token, 0.0)\r\n tf_dict[token] += 1 / _len\r\n\r\n return tf_dict","def preprocess(document, max_features=150, max_sentence_len=300):\n\n def lemmatize(token, tag):\n \"\"\"\n Converts the tag to a WordNet POS tag, then uses that\n tag to perform an accurate WordNet lemmatization.\n \"\"\"\n tag = {\n 'N': wn.NOUN,\n 'V': wn.VERB,\n 'R': wn.ADV,\n 'J': wn.ADJ\n }.get(tag[0], wn.NOUN)\n\n return WordNetLemmatizer().lemmatize(token, tag)\n\n def vectorize(doc, max_features, max_sentence_len):\n \"\"\"\n Converts a document into a sequence of indices of length max_sentence_len retaining only max_features unique words\n \"\"\"\n tokenizer = Tokenizer(num_words=max_features)\n tokenizer.fit_on_texts(doc)\n doc = tokenizer.texts_to_sequences(doc)\n doc_pad = pad_sequences(doc, padding='pre', truncating='pre', maxlen=max_sentence_len)\n return np.squeeze(doc_pad), tokenizer.word_index\n\n cleaned_document = []\n vocab = []\n\n # Break the document into sentences\n for sent in document:\n\n # Clean the text using a few regular expressions\n sent = re.sub(r\"[^A-Za-z0-9^,!.\\/'+-=]\", \" \", sent)\n sent = re.sub(r\"what's\", \"what is \", sent)\n sent = re.sub(r\"\\'\", \" \", sent)\n sent = re.sub(r\"@\", \" \", sent)\n sent = re.sub(r\"\\'ve\", \" have \", sent)\n sent = re.sub(r\"can't\", \"cannot \", sent)\n sent = re.sub(r\"n't\", \" not \", sent)\n sent = re.sub(r\"i'm\", \"i am \", sent)\n sent = re.sub(r\"\\'re\", \" are \", sent)\n sent = re.sub(r\"\\'d\", \" would \", sent)\n sent = re.sub(r\"\\'ll\", \" will \", sent)\n sent = re.sub(r\"(\\d+)(k)\", r\"\\g<1>000\", sent)\n sent = sent.replace(\"\\n\", \" \")\n\n lemmatized_tokens = []\n\n # Break the sentence into part of speech tagged tokens\n for token, tag in pos_tag(wordpunct_tokenize(sent)):\n\n # Apply preprocessing to the tokens\n token = token.lower()\n token = token.strip()\n token = token.strip('_')\n token = token.strip('*')\n\n # If punctuation ignore token and continue\n if all(char in set(string.punctuation) for char in token) or token in set(sw.words('english')):\n continue\n\n # Lemmatize the token\n lemma = lemmatize(token, tag)\n lemmatized_tokens.append(lemma)\n vocab.append(lemma)\n\n cleaned_document.append(lemmatized_tokens)\n\n vocab = sorted(list(set(vocab)))\n\n return cleaned_document, vocab","def get_counts(self):\n counts = {}\n for document in self.docs:\n for word in document:\n if word not in counts.keys():\n counts[word] = 1\n else:\n counts[word] += 1\n return counts","def collocationFinder(document,nbest=4):\n\tchain = lambda x : list(itertools.chain(*pos.tokenize_words(pos.tokenize_sents(x))))\n\tstopset = set(stopwords.words('english'))\n\tfilter_stops = lambda w: len(w) < 3 or w in stopset\n\tbcf = BigramCollocationFinder.from_words(chain(document))\n\tbcf.apply_word_filter(filter_stops)\n\treturn bcf.nbest(BigramAssocMeasures.likelihood_ratio, 4)","def compute_frequencies(num_words, documents):\n res = [0 for i in range(num_words)]\n sum = 0\n for word in documents:\n sum += 1\n tmp = set(word)\n for number in tmp:\n res[number] += 1\n \n res = [i / sum for i in res]\n return res","def process_document(text):\n words = preprocess(text)\n postings = {}\n for word, ix in words:\n if word in postings:\n wordinfo = postings[word]\n else:\n wordinfo = {\"frequency\": 0, \"indexes\": []}\n postings[word] = wordinfo\n wordinfo[\"frequency\"] += 1\n wordinfo[\"indexes\"].append(ix)\n return postings","def build_vocab(self, min_count=3):\n word2count = defaultdict(int)\n for sentence in self.tokenized_corpus:\n for word in sentence:\n word2count[word] += 1\n\n word2dict = {}\n word2dict['PAD'] = {'id': 0}\n word2dict['UNK'] = {'id': 1}\n for word in word2count:\n if word2count[word] >= min_count:\n word2dict[word] = {'id': len(word2dict), 'count': word2count[word]}\n self.vocab = word2dict","def computeWordsFrequencies(self):\n token_stream = self._tokenize(self.readable)\n token_map = self._countTokens(token_stream)\n # print token_map.items()\n return sorted(token_map.items(), key = lambda x : x[1], reverse = True)","def _create_dictionary(self, document):\n words = self._normalize_words(document.words)\n unique_words = frozenset(words)\n return dict((word, idx) for idx, word in enumerate(unique_words))","def get_distribution(doc):\n word_count = {}\n word_count = clean(doc, word_count)\n factor = 1.0 / sum(word_count.values())\n dist = {k: v * factor for k, v in word_count.items()}\n return dist","def getTokenCollectionFrequency(self, token):\n\n wordid = self.find_word_in_dictionary(token)\n # word is not in the dictionary\n if wordid == -1:\n print(\"Token is not in the dictionary\")\n return 0\n\n with open(self.word_to_docs_path, 'rb') as bin:\n while bin.tell() != os.fstat(bin.fileno()).st_size:\n # get wordid:\n wordid_in_file = int.from_bytes(bin.read(4), 'big')\n # get frequency:\n frequency = int.from_bytes(bin.read(4), 'big')\n # skip documents:\n int.from_bytes(bin.read(4 * frequency), 'big')\n if wordid_in_file == wordid:\n return frequency\n return 0","def add(self, document):\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\n if not token.isalpha():\n continue\n\n if token in self.stopwords:\n continue\n \n if self.stemmer:\n token = self.stemmer.stem(token)\n \n if self.__unique_id not in self.index[token]:\n self.index[token].append(self.__unique_id)\n \n self.documents[self.__unique_id] = document\n self.__unique_id += 1","def createBagOfWords(df, n):\n from nltk.tokenize import word_tokenize\n from nltk.corpus import stopwords\n import string\n from collections import Counter\n from nltk.stem.porter import PorterStemmer\n \n ps = PorterStemmer()\n stop_words = set(stopwords.words('english') + list(string.punctuation) + ['...' , ',' , '“', '”', '.', 'fig', '.fig'])\n \n dfDict = {}\n# df['count'] = df.groupby('Text')['Text'].transform(pd.Series.value_counts)\n# df.sort_values('count', ascending = False)\n# df.drop('count', axis = 1)\n dfLength = len(df.index)\n for i in range(1, dfLength):\n text = df['Text'][i]\n if dfDict.__contains__(text):\n df['Text'][i] = dfDict.get(text)\n else:\n textModified = text.lower()\n textModified = textModified.replace(',', '')\n textModified = textModified.replace('.', '')\n textModified = textModified.split()\n textModified = [ps.stem(word) for word in textModified if not word in set(stop_words) and len(word) > 1]\n textModified = ' '.join(textModified)\n df['Text'][i] = textModified\n dfDict[text] = textModified\n \n from sklearn.feature_extraction.text import CountVectorizer\n cv = CountVectorizer()\n textBagOfWords = cv.fit_transform(df['Text']).toarray()\n textBagOfWords = pd.DataFrame(textBagOfWords)\n df = df.drop(['Text'], axis = 1)\n df = pd.concat([df, textBagOfWords], axis = 1)\n return df","def doc2idx(self, document, unknown_word_index=-1):\n if isinstance(document, string_types):\n raise TypeError(\"doc2idx expects an array of unicode tokens on input, not a single string\")\n\n document = [word if isinstance(word, unicode) else unicode(word, 'utf-8') for word in document]\n return [self.token2id.get(word, unknown_word_index) for word in document]","def bow(data_frame, description):\n text = list(data_frame['article'])\n vectorizer = CountVectorizer(stop_words='english') # create the transform\n vectorizer.fit(text) # tokenize and build vocab\n # save bow vectorizer as pickle\n with open('resources/bow_encoder_' + description + '.pkl', 'wb') as f:\n pickle.dump(vectorizer.vocabulary_, f)\n f.close()\n data_frame['bow'] = data_frame['article'].apply(lambda x: vectorizer.transform([x]))\n return data_frame","def extract_features(document):\n document_words = set(document)\n features = {}\n global word_features\t\n for word in word_features:\n features['contains(%s)' % word] = (word in document_words)\n return features","def q_tokenize(document):\n final_words = []\n avoided_words = [] # WORDS WHICH ARE TO BE AVOIDED IN THE FINAL LIST\n \n # making the avoided_words list\n for word in string.punctuation: # the string library has a string of punctuations\n avoided_words.append(word)\n for word in nltk.corpus.stopwords.words(\"english\"): # the nltk lib. has a list of stopwords commonly used in english\n avoided_words.append(word)\n\n tokens = nltk.word_tokenize(document)","def wordbag( text, ignore_words = Ignore_words ) :\n iter = (stripword(s) for s in text.lower().split() if stripword(s) not in ignore_words)\n result = {}\n for x in iter :\n if result.has_key(x) :\n result[x] += 1\n else :\n result[x] = 1\n return result","def bin_inscriptions(corpus):\n doc_bin = DocBin(attrs=[\"LEMMA\",\"TAG\",\"POS\",\"DEP\",\"HEAD\"], store_user_data=True)\n for c in corpus:\n doc = nlp(c)\n doc_bin.add(doc)\n\n with open('dbg.bin','wb') as f:\n f.write(doc_bin.to_bytes())","def get_words(doc):\n splitter = re.compile('\\\\W*')\n # Split the words by non-alpha characters\n words = [s.lower() for s in splitter.split(doc) \n if len(s)>2 and len(s)<20]\n # Return the unique set of words only\n return dict([(w,1) for w in words])","def get_document_complexe_tags(self, document):\n kw_extractor = yake.KeywordExtractor(lan=\"en\", n=3, top=30)\n keywords = kw_extractor.extract_keywords(document)\n\n complexe_tag = []\n for keyword in keywords:\n if keyword[-1] >= 0.1:\n break\n complexe_tag.append(keyword[0])\n return complexe_tag","def get_terms(document):\n q = get_mapped(document)\n tokens = tockenizer(q)\n terms = analizer(tokens)\n\n return terms","def get_word_frequencies(documents):\n cv_model = CountVectorizer(binary=True)\n tf_matrix = cv_model.fit_transform(documents)\n tf_matrix_transpose = tf_matrix.transpose()\n\n vocabulary = get_vocabulary(documents)\n n_words = len(vocabulary)\n\n word_frequency = {}\n word_frequency_in_documents = {}\n\n for word_idx in range(n_words):\n word = vocabulary[word_idx]\n tf_word = tf_matrix_transpose[word_idx]\n\n # getnnz -> Get the count of explicitly-stored values (nonzeros)\n word_frequency[word] = float(tf_word.getnnz(1))\n # nonzero -> Return the indices of the elements that are non-zero\n word_frequency_in_documents[word] = set(tf_word.nonzero()[1])\n\n return word_frequency, word_frequency_in_documents","def getBiwords(self, words):\n bigrams_val = nltk.bigrams(words)\n biwords = []\n for word in bigrams_val:\n biwords.append(word)\n return biwords","def pos_tag_counts(doc):\n tags = []\n for token in doc:\n tags.append(token.pos_)\n frequency = dict(Counter(tags).most_common()) \n return frequency","def _create_word_count_dict(self):\n word_counts = dict()\n for wc in self.word_counts.all():\n word_counts[wc.word.name] = wc.count\n return word_counts","def get_tokens(self, document):\n raise NotImplementedError()","def entity_counts(doc):\n \n tags = []\n for token in doc.ents:\n tags.append(token.label_)\n frequency = dict(Counter(tags).most_common())\n\n return frequency","def test_bigrams():\n tokenizer = Tokenizer(bigram_freq=0.5)\n X = tokenizer.transform([[\"a b a b\"]])\n assert X[\"corpus\"][0] == [\"a_b\", \"a_b\"]\n assert isinstance(tokenizer.bigrams, pd.DataFrame)","def preprocess_corpus(corpus, stop_list, stop_words=True, stemm=True, bag_words=True):\n corpus_preprocessed = list()\n for element in corpus:\n new_element = dict()\n new_element['document'] = preprocess_document(element['text'], stop_list, stop_words, stemm, bag_words)\n new_element['id'] = element['id']\n corpus_preprocessed.append(new_element)\n\n return corpus_preprocessed","def learn_word_vocab(self, word_counts: typing.Counter[str]) -> Dict[str, int]:\r\n for token in set(self.required_tokens or []):\r\n word_counts[token] = int(2 ** 31)\r\n word_counts[self.PAD] = int(2 ** 32) # Make sure that PAD gets id=0\r\n sorted_word_counts = sorted(word_counts.items(), key=lambda p: -p[1])\r\n return {word: idx for idx, (word, count) in enumerate(sorted_word_counts[: self.word_vocab_size])}","def clean_docs(self,docs):\n\n # Remove numbers, but not words that contain numbers.\n docs = [[token for token in doc if not token.isnumeric()] for doc in docs]\n\n # Remove words that are only one character.\n docs = [[token for token in doc if len(token) > 1 and token not in stop_words] for doc in docs]\n\n # lemmatizer = WordNetLemmatizer()\n # docs = [[lemmatizer.lemmatize(token) for token in doc] for doc in docs]\n\n # Add bigrams and trigrams to docs (only ones that appear 20 times or more).\n bigram = Phrases(docs, min_count=20)\n for idx in range(len(docs)):\n for token in bigram[docs[idx]]:\n if '_' in token:\n # Token is a bigram, add to document.\n docs[idx].append(token)\n\n # Create a dictionary representation of the documents.\n dictionary = Dictionary(docs)\n\n # Filter out words that occur less than 20 documents, or more than 50% of the documents.\n dictionary.filter_extremes(no_below=20, no_above=0.5)\n\n # Bag-of-words representation of the documents.\n corpus = [dictionary.doc2bow(doc) for doc in docs]\n\n return docs,dictionary,corpus","def extractWordFeatures(x):\n # BEGIN_YOUR_CODE (around 5 lines of code expected)\n a = Counter(x.split())\n return dict(a)\n # END_YOUR_CODE","def readDocument(self, filename, voc):\n f = open(filename, encoding=\"utf8\")\n text = f.read()\n f.close()\n table = str.maketrans(self.punct, \" \" * len(self.punct))\n text = text.translate(table)\n # Start with all zeros\n bow = np.zeros(len(voc))\n for w in text.split():\n # If the word is the vocabulary...\n if w in voc:\n # ...increment the proper counter.\n index = voc[w]\n bow[index] += 1\n return bow","def features_extract(document, wordset):\n words_doc = nltk.FreqDist(document)\n features = []\n for word in wordset:\n features.append(words_doc[word])\n return features","def vectorize_doc_simple(self, doc):\n\n bow = defaultdict(float)\n tokens = [token.lower() for token in doc.split()]\n for token in tokens:\n bow[token] += 1.0\n return bow","def word_tag_counts (count_file):\r\n wordtagcounts = defaultdict(list)\r\n f = open(count_file, 'r')\r\n for line in f:\r\n fields = line.split(\" \")\r\n if fields[1] != 'WORDTAG':\r\n continue\r\n count = int(fields[0].strip())\r\n tag = fields[2].strip()\r\n word = fields[3].strip()\r\n wordtagcounts[word].append((tag, count)) \r\n f.close() \r\n return wordtagcounts","def get_feature_set_SB(tweet):\n #pos-tag frequencies\n# print \"Tagged words in tweet: \", tweet.tagged_words\n pos_tag_freq = {}\n additional_freq = {}\n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# if tag=='PRtinf':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJS':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJ':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='NP':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='DET':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='P':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n if tag in ADJECTIVES:\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\n elif tag in ADVERBS: \n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\n elif tag in PRONOUNS:\n additional_freq['pronoun'] = 1\n except KeyError:\n continue\n# print \"Tag frequencies: \", pos_tag_freq\n for key in pos_tag_freq.keys():\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \n #Number of exclamation marks, number of emoticons,\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\n if emoticons>0:\n additional_freq['emoticons'] = emoticons*1.0\n if tweet.nrof_exclamations>0:\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\n \n# print \"Additional frequencies: \", additional_freq\n# raw_input(\"Continue?\")\n \n #Concatenate the dicts\n features= dict(pos_tag_freq.items() + additional_freq.items())\n# print \"All features: \", features\n# raw_input(\"Continue?\")\n return features","def convert_corpus_to_lists(corpus_data):\r\n global ne_tags_set\r\n\r\n res_lsts = []\r\n for sent in corpus_data.iob_sents():\r\n if not sent:\r\n continue\r\n words, nes = [], []\r\n for tup in sent:\r\n words.append(tup[0])\r\n nes.append(tup[2])\r\n ne_tags_set.update(nes)\r\n res_lsts.append({'words': words, 'nes': nes})\r\n\r\n return res_lsts","def count_words(data, number_word_frequency_results=40):\n current_max_sentence_size = 0\n count_word_frequency = Counter()\n for entry in data:\n print (entry)\n terms_all = [term for term in entry]\n count_word_frequency.update(terms_all)\n return count_word_frequency.most_common(number_word_frequency_results)","def create_tag_list(faker_obj, num=10):\n fake = faker_obj\n return fake.words(nb=num)","def _get_bag_of_pos(words, index, N, target_len=1):\n bos = DummyWord(pos=utils.BEGIN_OF_SENTENCE, upos=utils.BEGIN_OF_SENTENCE, dependency_relation=utils.BEGIN_OF_SENTENCE)\n eos = DummyWord(pos=utils.END_OF_SENTENCE, upos=utils.END_OF_SENTENCE, dependency_relation=utils.END_OF_SENTENCE)\n words = [bos] * N + words + [eos] * N\n index += N\n return [_get_word_feature(w) for w in words[index-N:index] + [words[index]] + words[index+target_len:index+target_len+N]]","def bow2tfidf(doc_term_bow, corpus_tfidf):\n doc_term_tfidf = corpus_tfidf[doc_term_bow]\n scipy_tfidf = corpus2csc(doc_term_tfidf, num_terms = len(corpus_tfidf.idfs))\n tfidf_mtx = csc_matrix(scipy_tfidf).T.toarray()\n# print(f'The dimensions of tfidf matrix = {tfidf_mtx.shape}')\n return tfidf_mtx"],"string":"[\n \"def make_bag_words(document_tokenized):\\n bag_words = dict()\\n for token in document_tokenized:\\n if token in bag_words.keys():\\n bag_words[token] += 1\\n else:\\n bag_words[token] = 1\\n return bag_words\",\n \"def sentencesToBow(documents):\\n bowSentences = []\\n dictionary = Dictionary(documents)\\n\\n numDocs = len(documents);\\n avgDocLength = sum(map(len, documents))/numDocs\\n for document in documents:\\n bowSentence = []\\n docLength = len(document)\\n bowDoc = dictionary.doc2bow(document)\\n for bowTerm in bowDoc:\\n\\n docTermFreq = bowTerm[1]\\n termDocFreq = dictionary.dfs[bowTerm[0]]\\n\\n termWeight = docTermWeight(docTermFreq, termDocFreq, docLength, avgDocLength, numDocs, k=5, b=0.1)\\n newBowTerm = (bowTerm[0], termWeight)\\n bowSentence.append(newBowTerm)\\n\\n bowSentences.append(bowSentence)\\n\\n return bowSentences, dictionary\",\n \"def word_frequency(self, document):\\n freq_table = {}\\n words = nltk.word_tokenize(document)\\n for word in words:\\n if word in freq_table:\\n freq_table[word] = freq_table.get(word) + 1\\n else:\\n freq_table[word] = 1\\n # cut down the frequency table so that only common words are scored for\\n freq_table = sorted(freq_table.items(), key=lambda x: x[1], reverse=True)\\n scorable_words = []\\n for word, occ in freq_table:\\n # set threshold as words appearing x times or more - set to optimal valeue = 0\\n # in hindsight this can just be deleted\\n if int(occ) > 0:\\n scorable_words.append(word)\\n else:\\n break\\n self.sent_pos = self.sent_pos + 1 \\n return scorable_words\",\n \"def gen_bag_of_words_df(self):\\n\\t\\tdef word_vector(doc_text):\\n\\t\\t\\tfreqs = pd.Series(collections.Counter(doc_text.split()))\\n\\t\\t\\treturn freqs.loc[set(freqs.index.values)|set(self.stems)]\\n\\t\\tself.bagofwords = self.dataframe.text.apply(word_vector).replace({np.nan:0})\",\n \"def bow_vec(doc):\\n return CECTORIZER.transform([doc]).toarray()\",\n \"def bag_of_words(tokenized_sentence, all_words):\\n\\n tokenized_sentence = [stem(w) for w in tokenized_sentence]\\n #print(tokenized_sentence)\\n bag = np.zeros_like(all_words, dtype=np.float32)\\n for idx, w in enumerate(all_words):\\n if w in tokenized_sentence:\\n bag[idx] = 1.0\\n\\n return bag\",\n \"def add_doc(self, document):\\n # Split document up into list of strings\\n #words = self.tokenize(document)\\n words = document\\n # Count word frequencies in this document\\n word_counts = {}\\n for word in words:\\n word_counts[word] = word_counts.get(word, 0) + 1\\n # Add word counts as new row to sparse matrix\\n self.sparse.append(word_counts)\\n # Add to total document count for each word\\n for word in word_counts:\\n self.doc_count[word] = self.doc_count.get(word, 0) + 1\",\n \"def tokenize(document):\\n token = nltk.word_tokenize(document)\\n\\n output = [word.lower() for word in token if (word not in string.punctuation and word not in nltk.corpus.stopwords.words(\\\"english\\\"))]\\n\\n return output\",\n \"def bow(tokens):\\n return dict(collections.Counter(re.findall(r'\\\\w+', \\\" \\\".join(tokens))))\",\n \"def tokenize(document):\\n\\n # Unable to acquire 'stopwords' without these snippets due to my python config\\n # import ssl\\n # ssl._create_default_https_context = ssl._create_unverified_context\\n # nltk.download('stopwords')\\n\\n stops = nltk.corpus.stopwords.words(\\\"english\\\")\\n\\n all_words = list()\\n cleaned_words = list()\\n\\n all_words = nltk.word_tokenize(document)\\n\\n for word in all_words:\\n word = word.strip()\\n word = word.lower()\\n\\n if word in stops \\\\\\n or not word \\\\\\n or word in string.punctuation \\\\\\n or word.strip(\\\"=\\\") != word:\\n continue\\n else:\\n cleaned_words.append(word)\\n\\n return cleaned_words\",\n \"def featurize(self, data):\\n \\n bag_of_words = []\\n\\n tokens = data.split()\\n\\n for i in tokens:\\n bag_of_words.append((i, True))\\n\\n return bag_of_words\",\n \"def preproc_doc(document):\\n tokenizer = tokenization.FullTokenizer(\\n vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)\\n\\n # document = [\\n # tokenization.convert_to_unicode(\\n # unidecode.unidecode(line.decode(\\\"utf-8\\\"))) for line in document\\n # ]\\n\\n sent_tokens = [tokenizer.tokenize(sent) for sent in document if sent]\\n sent_tokens = [sent for sent in sent_tokens if len(sent) > 1]\\n if len(sent_tokens) < 8:\\n return []\\n\\n # Convert token lists into ids and add any needed tokens and padding for BERT\\n tf_example = convert_instance_to_tf_example(tokenizer, sent_tokens,\\n FLAGS.max_sent_length,\\n FLAGS.max_para_length)\\n\\n # Serialize TFExample for writing to file.\\n tf_examples = [tf_example.SerializeToString()]\\n\\n return tf_examples\",\n \"def bagOfWords(self):\\n if self._bow is None:\\n self._bow = {}\\n for word in self._words:\\n if word['word'] in self._bow:\\n self._bow[word['word']] += 1\\n else:\\n self._bow[word['word']] = 1\\n return self._bow\",\n \"def get_tokenizer_result(blob):\\n return list(blob.words)\",\n \"def gen_words(self, doc):\\n pattern = re.compile(u'[\\\\\\\\s\\\\\\\\d,.<>/?:;\\\\'\\\\\\\"[\\\\\\\\]{}()\\\\\\\\|~!@#$%^&*\\\\\\\\-_=+a-zA-Z，。《》、？：；“”‘’｛｝【】（）…￥！—┄－]+')\\n doc = re.sub(pattern, ' ', doc)\\n suffix_indexes = index_of_sorted_suffix(doc, self.max_word_len)\\n word_cands = {}\\n # compute frequency and neighbors\\n for suf in suffix_indexes:\\n word = doc[suf[0]:suf[1]]\\n if word not in word_cands:\\n word_cands[word] = WordInfo(word)\\n word_cands[word].update(doc[suf[0] - 1:suf[0]], doc[suf[1]:suf[1] + 1])\\n # compute probability and entropy\\n length = len(doc)\\n for k in word_cands:\\n word_cands[k].compute(length)\\n word_cands[k].compute_pp(self.pos_prop)\\n # compute aggregation of words whose length > 1\\n values = sorted(word_cands.values(), key=lambda x: len(x.text))\\n for v in values:\\n if len(v.text) == 1:\\n continue\\n v.compute_cohesion(word_cands)\\n\\n return sorted(values, key=lambda v: v.freq, reverse=True)\",\n \"def tokenize(document):\\n words = [word.lower() for word in nltk.word_tokenize(document) if word not in string.punctuation and word not in nltk.corpus.stopwords.words(\\\"english\\\") ]\\n\\n return sorted(words)\",\n \"def convert_word_to_count(counter={}, doc=[]):\\n for sentence in doc:\\n for word in sentence.split():\\n if word not in counter:\\n counter[word] = 1\\n else:\\n counter[word] += 1\\n return counter\",\n \"def make_word_to_freq(self):\\n\\t\\tword_to_freq = {}\\n\\t\\tdocuments = self.tokenized_documents[\\\"train\\\"]\\n\\t\\tfor document in documents:\\n\\t\\t\\tfor word in document:\\n\\t\\t\\t\\tif not word in self.worddict: # make sure we have not found one of the pre-defined words\\n\\t\\t\\t\\t\\tword_to_freq[word] = word_to_freq.get(word, 0) + 1\\n\\t\\t\\n\\t\\treturn word_to_freq\",\n \"def tokenize(document):\\n\\n # Initialize the list of words, punctuation and stopwords\\n keywords = []\\n punctuations_list = string.punctuation\\n stopwords_list = nltk.corpus.stopwords.words(\\\"english\\\")\\n\\n # Make a naive tokenized copy of the `document`\\n naive_list = nltk.word_tokenize(document)\\n\\n for item in naive_list:\\n\\n # Ignore punctuations or stopwords\\n if (item in punctuations_list) or (item in stopwords_list) or (len(item) < 4):\\n continue\\n\\n # Add document by coverting all words to lowercase\\n keywords.append(item.lower())\\n\\n return keywords\",\n \"def freq(word, document):\\n return document.split(None).count(word)\",\n \"def getReviewsWithToken(self, token):\\n\\n wordid = self.find_word_in_dictionary(token)\\n # word is not in the dictionary\\n if wordid == -1:\\n print(\\\"Token is not in the dictionary\\\")\\n return 0\\n\\n with open(self.doc_to_words_path, 'rb') as bin:\\n tup = []\\n while bin.tell() != os.fstat(bin.fileno()).st_size:\\n # get wordid:\\n docid_in_file = int.from_bytes(bin.read(4), 'big')\\n # get frequency:\\n frequency = int.from_bytes(bin.read(4), 'big')\\n # count words:\\n count = 0\\n for i in range(frequency):\\n wordid_in_file = int.from_bytes(bin.read(4), 'big')\\n if wordid == wordid_in_file:\\n count += 1\\n tup.append(docid_in_file)\\n tup.append(count)\\n return tuple(tup)\",\n \"def bagOfWords(self,phrase):\\n return self._support.bagOfWords(phrase)\",\n \"def get_vocab(self):\\n word2id = {}\\n for document in self.docs:\\n for word in document:\\n if word not in word2id.keys():\\n word2id[word] = len(word2id)\\n return word2id\",\n \"def get_doc(corpus):\\n doc_info = []\\n\\n for idx, text in enumerate(corpus):\\n count = len(word_tokenize(text))\\n doc_info.append({'doc_length': count})\\n\\n return doc_info\",\n \"def vectorize_doc(document):\\n # return document vector for tokenized input doc\\n return bc.encode([document])[0]\",\n \"def tokenize(document):\\n import string\\n\\n # tokenize the given document\\n words = nltk.tokenize.word_tokenize(document)\\n words = [word.lower() for word in words]\\n\\n # filter words from punctuations and stopwords\\n loop_words = words.copy()\\n for word in loop_words:\\n if word in [char for char in string.punctuation] + nltk.corpus.stopwords.words(\\\"english\\\"):\\n words.remove(word)\\n\\n return words\",\n \"def vocabulary(corpus_tokenized):\\n vocab = list()\\n for element in corpus_tokenized:\\n document = element['document']\\n for word in document:\\n if word not in vocab:\\n vocab.append(word)\\n return vocab\",\n \"def num_bigram(doc):\\n matched_spans = []\\n matches = matcher(doc)\\n for match_id, start, end in matches:\\n span = doc[start:end]\\n matched_spans.append(span)\\n for span in matched_spans: # merge into one token after collecting all matches\\n span.merge()\\n return doc\",\n \"def doc2vec(self, doc):\\n contained_words = self.cut_words(doc)\\n vec = []\\n for wrd in self.words:\\n tf = contained_words.count(wrd) / len(contained_words)\\n df = self.dfdict[wrd] + 1\\n if wrd in contained_words: df += 1\\n idf = log10((len(self.docs) + 1) / df)\\n vec.append(tf * idf)\\n return vec\",\n \"def wordCount(document):\\n return float(len(document.split(None)))\",\n \"def corpus2mallet(self, corpus, file_like):\\n for docno, doc in enumerate(corpus):\\n if self.id2word:\\n tokens = chain.from_iterable([self.id2word[tokenid]] * int(cnt) for tokenid, cnt in doc)\\n else:\\n tokens = chain.from_iterable([str(tokenid)] * int(cnt) for tokenid, cnt in doc)\\n file_like.write(utils.to_utf8(\\\"%s 0 %s\\\\n\\\" % (docno, ' '.join(tokens))))\",\n \"def tokenize_into_words(myblob):\\n set_constraint = re.compile(r'[^a-zA-Z0-9]')\\n tokenize_to_text = set_constraint.split(myblob) # The blob is spilt into words and the given constraints are applied\\n words = [word for word in tokenize_to_text if word]\\n return words\",\n \"def tokenize_and_split_bis(sms_file):\\n \\n dic = {}\\n list1 = []\\n list2 = []\\n list3 = []\\n list4 = []\\n i = -1\\n document = 0\\n terms = 0\\n new_document = True\\n ham = True\\n for line in open(sms_file, 'r').readlines():\\n w = []\\n document += 1\\n new_document = True\\n for word in line.split():\\n i = i + 1\\n if word == \\\"ham\\\":\\n ham = True\\n i = i - 1\\n elif word == \\\"spam\\\":\\n ham = False\\n i = i - 1\\n else:\\n if word not in dic:\\n dic[word] = i\\n w.append(dic[word])\\n list3.append(1)\\n list4.append(1)\\n new_document = False\\n terms += 1\\n else : \\n i = i - 1\\n w.append(dic[word])\\n list4[dic[word]] += 1\\n terms += 1\\n if new_document: \\n list3[dic[word]] += 1\\n new_document = False\\n \\n if ham and w !=[]:\\n list2.append(w)\\n elif ham == False and w !=[]:\\n list1.append(w)\\n\\n moy = 0\\n len_dic = len(dic.keys())\\n list5 = [0 for x in range(len_dic)]\\n for key in dic.keys():\\n if list4[dic[key]] > 0:\\n tf = list4[dic[key]] / terms\\n idf = math.log(document / list3[dic[key]])\\n tfIdf = tf * idf\\n list5[dic[key]] = tfIdf\\n # print(\\\"the word \\\" + str(key) + \\\" appairs \\\" + str(list4[dic[key]]) + \\\" times.\\\")\\n # print(\\\"his frequency is \\\" + str(list4[dic[key]] / terms) )\\n # print(\\\"the word \\\" + str(key) + \\\" appairs \\\" + str(list3[dic[key]]) + \\\" times in each document.\\\")\\n # print(\\\"his frequency is \\\" + str(idf))\\n # print(\\\"utility \\\" + str(tfIdf))\\n moy += tfIdf\\n \\n moy = moy / len_dic \\n # print(moy)\\n dic_bis = {}\\n i = -1\\n for key in dic.keys():\\n value = list5[dic[key]]\\n # print(str(value))\\n if (value > oracle * moy):\\n i += 1\\n dic_bis[key] = i\\n # else:\\n # print(\\\"not pass \\\" + key + \\\" \\\" + str(value))\\n \\n \\n # print(dic_bis == dic)\\n # print(dic)\\n return dic_bis,list1,list2\",\n \"def bag_of_words(batch, TEXT):\\n V = len(TEXT.vocab)\\n X = torch.zeros(batch.text.size(0), V)\\n ones = torch.ones(batch.text.size(1))\\n for b in range(batch.text.size(0)):\\n X[b].index_add_(0, batch.text.data[b], ones)\\n X[b][TEXT.vocab.stoi['<pad>']] = 0\\n X = Variable(X, requires_grad=False)\\n return X\",\n \"def extract_terms(document):\\n tokens = word_tokenize(document)\\n stemmer = PorterStemmer()\\n terms = {} # Dictionary {term: appearances}\\n word_count = 0 # To return total (meaningful) word count\\n for token in tokens:\\n token = token.lower() # Lowercase\\n token = token.strip(string.punctuation) # Remove punctuation\\n if token and token not in stopwords.words(\\\"english\\\"): # Remove stopwords\\n token = stemmer.stem(token) # Using Porter Stemmer\\n if token not in terms:\\n terms[token] = 1\\n else:\\n terms[token] += 1\\n word_count += 1\\n return terms, word_count\",\n \"def get_words_with_nplus_frequency(tokenized_sentences, count_threshold):\\r\\n\\r\\n closed_vocab = []\\r\\n \\r\\n\\r\\n word_counts = count_words(tokenized_sentences)\\r\\n \\r\\n\\r\\n for word, cnt in word_counts.items(): # complete this line\\r\\n \\r\\n\\r\\n if cnt >= count_threshold:\\r\\n \\r\\n # append the word to the list\\r\\n closed_vocab.append(word)\\r\\n \\r\\n return closed_vocab\",\n \"def tokenize(document):\\n words = nltk.word_tokenize(document)\\n # tokenize files into a list of words\\n return [\\n word.lower() for word in words\\n # filter out all punctuation (import string) and all stopwords\\n if not all(char in string.punctuation for char in word) \\n and word not in nltk.corpus.stopwords.words(\\\"english\\\")\\n ]\",\n \"def bag_of_features(self, word, normalize=True):\\n word_features = self.word_fts(word, normalize)\\n features = [v + f for f in self.names for v in ['+', '0', '-']]\\n bag = collections.OrderedDict()\\n for f in features:\\n bag[f] = 0\\n vdict = {-1: '-', 0: '0', 1: '+'}\\n for w in word_features:\\n for (f, v) in w.items():\\n bag[vdict[v] + f] += 1\\n return numpy.array(list(bag.values()))\",\n \"def word_count(self, document):\\n start_time = time.time()\\n dictionary = dict()\\n counter = defaultdict(int)\\n for line in document.splitlines():\\n for word in line.split():\\n if word not in PUNCTUATION_MARK:\\n counter[word] += 1\\n for word, cnt in sorted(counter.items(), key=lambda x: (-x[1], x[0])):\\n dictionary[word] = cnt\\n self.log.info(\\\"Duration count dictionary: {duration}\\\".format(duration=float(time.time() - start_time)))\\n return dictionary\",\n \"def countFreq(self,document):\\n self.document = document\\n vocab=['python','js','android','php','django','javascript','oracle','ruby','rails','java']\\n cnt_vector = CountVectorizer(vocabulary=vocab)\\n self.freq_term_matrix = cnt_vector.fit_transform(self.document)\\n return self.freq_term_matrix.toarray()\",\n \"def tokenize(document):\\n raw_words=[word.lower() for word in nltk.word_tokenize(document) if word.isalpha()]\\n raw_words=[word.lower() for word in raw_words]\\n final_words=[]\\n for word in raw_words:\\n if word not in string.punctuation and word not in nltk.corpus.stopwords.words(\\\"english\\\"):\\n final_words.append(word.lower())\\n return final_words\",\n \"def word_frequency(book):\\n unique_dict = unique_words(book)\\n\\n word_array = pd.DataFrame(list(unique_dict.items()), columns=['Word', 'Occurence'])\\n\\n return word_array\",\n \"def document_to_lda_features(lda_model, document):\\n topic_importances = lda_model.get_document_topics(document, minimum_probability=0)\\n topic_importances = numpy.array(topic_importances)\\n return topic_importances[:,1]\",\n \"def parse_doc(doc,vocab):\\n doc=doc.lower()\\n doc=re.sub(r'-',' ',doc)\\n doc=re.sub(r' +',' ',doc) # turn multiple spaces into a single space\\n doc=re.sub(r'[^a-z ]','',doc) # remove anything that is not a-z or space\\n words=doc.split()\\n word_vocab=[vocab.get(word,-1) for word in words]\\n words_dict=collections.Counter(word_vocab)\\n del words_dict[-1] # ignore the words outside the vocabulary\\n #wordid=words_dict.keys()\\n #wordcnt=words_dict.values()\\n return sorted(words_dict.items())\",\n \"def extract(self, document):\\n f_num = len(self.feature_list)\\n feature_vector = np.zeros((f_num,))\\n words = document.split()\\n for i in xrange(len(words)):\\n for n in self.ns:\\n ngram = self.try_get_ngram(words, n, i)\\n if ngram and ngram in self.ngrams:\\n self.add_ngram(feature_vector, ngram)\\n return feature_vector\",\n \"def tokenize(document):\\n nltk.download('punkt')\\n nltk.download('stopwords')\\n wordList = nltk.word_tokenize(document.lower())\\n punctuation = string.punctuation\\n stopWords = nltk.corpus.stopwords.words(\\\"english\\\")\\n listCopy = copy.deepcopy(wordList)\\n for w in listCopy:\\n if w in stopWords or w in punctuation:\\n newList = list(filter(w.__ne__, wordList))\\n wordList = newList\\n return wordList\",\n \"def count_words_sents(self, doc_array):\\n total_num_sents = []\\n total_num_words = []\\n for doc in doc_array:\\n sents = sent_tokenize(doc)\\n total_num_sents.append(len(sents))\\n temp_num_words = []\\n for sent in sents:\\n num_words = word_tokenize(sent)\\n temp_num_words.append(len(num_words))\\n total_num_words.append(temp_num_words)\\n return np.array(total_num_sents), np.array(total_num_words)\",\n \"def bag_of_words_model(features, target):\\n target = tf.one_hot(target, 2, 1, 0)\\n features = tf.contrib.layers.bow_encoder(\\n features, vocab_size=n_words, embed_dim=Embedding_size, scope=\\\"input_layer\\\")\\n hidden_layer1 = tf.contrib.layers.fully_connected(features, 100, scope=\\\"hidden_layer1\\\")\\n logits = tf.contrib.layers.fully_connected(hidden_layer1, 2, scope=\\\"output_layer\\\",\\n activation_fn=None)\\n loss = tf.contrib.losses.softmax_cross_entropy(logits, target)\\n train_op = tf.contrib.layers.optimize_loss(\\n loss, tf.contrib.framework.get_global_step(),\\n optimizer='Adam', learning_rate=0.01)\\n return (\\n {'class': tf.argmax(logits, 1),\\n 'prob': tf.nn.softmax(logits)},\\n loss, train_op)\",\n \"def get_vocabulary(documents):\\n cv_model = CountVectorizer(binary=True)\\n cv_model.fit(documents)\\n\\n vocabulary = cv_model.get_feature_names()\\n vocabulary = list(map(str, vocabulary))\\n\\n return vocabulary\",\n \"def get_word_frequency(self, word, document):\\n return self.dictionary[word]['docs'][document]\",\n \"def get_number_of_words_in_document(self, document):\\n for _set in self.sets:\\n if document in _set:\\n return self.sets[_set][document]['number_of_words']\",\n \"def tfidf_bow(doc):\\n\\n if VECTORIZER == None:\\n sys.stderr.write(\\\"ERROR: Vectorizer not defined... Did you call set_vocab?\\\\n\\\")\\n return None\\n return VECTORIZER.transform([doc]).toarray()\",\n \"def lookup_bm25(self) -> list:\\n prox_by_doc = {}\\n for token in self._tokenizer.tokenize(self._query):\\n for token_info in self._index.get_token_search(token):\\n doc = token_info.doc\\n if doc not in prox_by_doc:\\n prox_by_doc[doc] = 0\\n prox_by_doc[doc] += token_info.weight\\n\\n return sorted(prox_by_doc.items(), key=lambda t: t[1], reverse=True)\",\n \"def doc2features(self,sent):\\n return [self.word2features(sent['tokens'], i) for i in range(len(sent['tokens']))]\",\n \"def word_occurrences(corpus):\\n occur_array = []\\n\\n for e in corpus:\\n occur = Counter(e)\\n occur_array.append(occur)\\n\\n return occur_array\",\n \"def mapWordsFrequencies(self):\\n token_stream = self._tokenize(self.readable)\\n token_map = self._countTokens(token_stream)\\n return token_map\",\n \"def create_bow(vocab, filepath):\\n bow = {}\\n # TODO: add your code here\\n wordcount = 0\\n wordcountnone = 0\\n c = 0\\n\\n for i in vocab:\\n c+=1\\n with open(filepath, 'r', encoding=\\\"utf-8\\\") as doc: ###############################################\\n for word in doc:\\n word = word.strip()\\n if(c==1):\\n if (word not in vocab):\\n wordcountnone += 1\\n if(i == str(word)):\\n wordcount += 1\\n #print(wordcount)\\n if(wordcount > 0):\\n bow[i] = wordcount\\n wordcount = 0\\n if(wordcountnone != 0):\\n bow[None] = wordcountnone\\n return bow\",\n \"def compute_tf(document):\\r\\n _len = len(document)\\r\\n tf_dict = {}\\r\\n for token in document:\\r\\n tf_dict.setdefault(token, 0.0)\\r\\n tf_dict[token] += 1 / _len\\r\\n\\r\\n return tf_dict\",\n \"def preprocess(document, max_features=150, max_sentence_len=300):\\n\\n def lemmatize(token, tag):\\n \\\"\\\"\\\"\\n Converts the tag to a WordNet POS tag, then uses that\\n tag to perform an accurate WordNet lemmatization.\\n \\\"\\\"\\\"\\n tag = {\\n 'N': wn.NOUN,\\n 'V': wn.VERB,\\n 'R': wn.ADV,\\n 'J': wn.ADJ\\n }.get(tag[0], wn.NOUN)\\n\\n return WordNetLemmatizer().lemmatize(token, tag)\\n\\n def vectorize(doc, max_features, max_sentence_len):\\n \\\"\\\"\\\"\\n Converts a document into a sequence of indices of length max_sentence_len retaining only max_features unique words\\n \\\"\\\"\\\"\\n tokenizer = Tokenizer(num_words=max_features)\\n tokenizer.fit_on_texts(doc)\\n doc = tokenizer.texts_to_sequences(doc)\\n doc_pad = pad_sequences(doc, padding='pre', truncating='pre', maxlen=max_sentence_len)\\n return np.squeeze(doc_pad), tokenizer.word_index\\n\\n cleaned_document = []\\n vocab = []\\n\\n # Break the document into sentences\\n for sent in document:\\n\\n # Clean the text using a few regular expressions\\n sent = re.sub(r\\\"[^A-Za-z0-9^,!.\\\\/'+-=]\\\", \\\" \\\", sent)\\n sent = re.sub(r\\\"what's\\\", \\\"what is \\\", sent)\\n sent = re.sub(r\\\"\\\\'\\\", \\\" \\\", sent)\\n sent = re.sub(r\\\"@\\\", \\\" \\\", sent)\\n sent = re.sub(r\\\"\\\\'ve\\\", \\\" have \\\", sent)\\n sent = re.sub(r\\\"can't\\\", \\\"cannot \\\", sent)\\n sent = re.sub(r\\\"n't\\\", \\\" not \\\", sent)\\n sent = re.sub(r\\\"i'm\\\", \\\"i am \\\", sent)\\n sent = re.sub(r\\\"\\\\'re\\\", \\\" are \\\", sent)\\n sent = re.sub(r\\\"\\\\'d\\\", \\\" would \\\", sent)\\n sent = re.sub(r\\\"\\\\'ll\\\", \\\" will \\\", sent)\\n sent = re.sub(r\\\"(\\\\d+)(k)\\\", r\\\"\\\\g<1>000\\\", sent)\\n sent = sent.replace(\\\"\\\\n\\\", \\\" \\\")\\n\\n lemmatized_tokens = []\\n\\n # Break the sentence into part of speech tagged tokens\\n for token, tag in pos_tag(wordpunct_tokenize(sent)):\\n\\n # Apply preprocessing to the tokens\\n token = token.lower()\\n token = token.strip()\\n token = token.strip('_')\\n token = token.strip('*')\\n\\n # If punctuation ignore token and continue\\n if all(char in set(string.punctuation) for char in token) or token in set(sw.words('english')):\\n continue\\n\\n # Lemmatize the token\\n lemma = lemmatize(token, tag)\\n lemmatized_tokens.append(lemma)\\n vocab.append(lemma)\\n\\n cleaned_document.append(lemmatized_tokens)\\n\\n vocab = sorted(list(set(vocab)))\\n\\n return cleaned_document, vocab\",\n \"def get_counts(self):\\n counts = {}\\n for document in self.docs:\\n for word in document:\\n if word not in counts.keys():\\n counts[word] = 1\\n else:\\n counts[word] += 1\\n return counts\",\n \"def collocationFinder(document,nbest=4):\\n\\tchain = lambda x : list(itertools.chain(*pos.tokenize_words(pos.tokenize_sents(x))))\\n\\tstopset = set(stopwords.words('english'))\\n\\tfilter_stops = lambda w: len(w) < 3 or w in stopset\\n\\tbcf = BigramCollocationFinder.from_words(chain(document))\\n\\tbcf.apply_word_filter(filter_stops)\\n\\treturn bcf.nbest(BigramAssocMeasures.likelihood_ratio, 4)\",\n \"def compute_frequencies(num_words, documents):\\n res = [0 for i in range(num_words)]\\n sum = 0\\n for word in documents:\\n sum += 1\\n tmp = set(word)\\n for number in tmp:\\n res[number] += 1\\n \\n res = [i / sum for i in res]\\n return res\",\n \"def process_document(text):\\n words = preprocess(text)\\n postings = {}\\n for word, ix in words:\\n if word in postings:\\n wordinfo = postings[word]\\n else:\\n wordinfo = {\\\"frequency\\\": 0, \\\"indexes\\\": []}\\n postings[word] = wordinfo\\n wordinfo[\\\"frequency\\\"] += 1\\n wordinfo[\\\"indexes\\\"].append(ix)\\n return postings\",\n \"def build_vocab(self, min_count=3):\\n word2count = defaultdict(int)\\n for sentence in self.tokenized_corpus:\\n for word in sentence:\\n word2count[word] += 1\\n\\n word2dict = {}\\n word2dict['PAD'] = {'id': 0}\\n word2dict['UNK'] = {'id': 1}\\n for word in word2count:\\n if word2count[word] >= min_count:\\n word2dict[word] = {'id': len(word2dict), 'count': word2count[word]}\\n self.vocab = word2dict\",\n \"def computeWordsFrequencies(self):\\n token_stream = self._tokenize(self.readable)\\n token_map = self._countTokens(token_stream)\\n # print token_map.items()\\n return sorted(token_map.items(), key = lambda x : x[1], reverse = True)\",\n \"def _create_dictionary(self, document):\\n words = self._normalize_words(document.words)\\n unique_words = frozenset(words)\\n return dict((word, idx) for idx, word in enumerate(unique_words))\",\n \"def get_distribution(doc):\\n word_count = {}\\n word_count = clean(doc, word_count)\\n factor = 1.0 / sum(word_count.values())\\n dist = {k: v * factor for k, v in word_count.items()}\\n return dist\",\n \"def getTokenCollectionFrequency(self, token):\\n\\n wordid = self.find_word_in_dictionary(token)\\n # word is not in the dictionary\\n if wordid == -1:\\n print(\\\"Token is not in the dictionary\\\")\\n return 0\\n\\n with open(self.word_to_docs_path, 'rb') as bin:\\n while bin.tell() != os.fstat(bin.fileno()).st_size:\\n # get wordid:\\n wordid_in_file = int.from_bytes(bin.read(4), 'big')\\n # get frequency:\\n frequency = int.from_bytes(bin.read(4), 'big')\\n # skip documents:\\n int.from_bytes(bin.read(4 * frequency), 'big')\\n if wordid_in_file == wordid:\\n return frequency\\n return 0\",\n \"def add(self, document):\\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\\n if not token.isalpha():\\n continue\\n\\n if token in self.stopwords:\\n continue\\n \\n if self.stemmer:\\n token = self.stemmer.stem(token)\\n \\n if self.__unique_id not in self.index[token]:\\n self.index[token].append(self.__unique_id)\\n \\n self.documents[self.__unique_id] = document\\n self.__unique_id += 1\",\n \"def createBagOfWords(df, n):\\n from nltk.tokenize import word_tokenize\\n from nltk.corpus import stopwords\\n import string\\n from collections import Counter\\n from nltk.stem.porter import PorterStemmer\\n \\n ps = PorterStemmer()\\n stop_words = set(stopwords.words('english') + list(string.punctuation) + ['...' , ',' , '“', '”', '.', 'fig', '.fig'])\\n \\n dfDict = {}\\n# df['count'] = df.groupby('Text')['Text'].transform(pd.Series.value_counts)\\n# df.sort_values('count', ascending = False)\\n# df.drop('count', axis = 1)\\n dfLength = len(df.index)\\n for i in range(1, dfLength):\\n text = df['Text'][i]\\n if dfDict.__contains__(text):\\n df['Text'][i] = dfDict.get(text)\\n else:\\n textModified = text.lower()\\n textModified = textModified.replace(',', '')\\n textModified = textModified.replace('.', '')\\n textModified = textModified.split()\\n textModified = [ps.stem(word) for word in textModified if not word in set(stop_words) and len(word) > 1]\\n textModified = ' '.join(textModified)\\n df['Text'][i] = textModified\\n dfDict[text] = textModified\\n \\n from sklearn.feature_extraction.text import CountVectorizer\\n cv = CountVectorizer()\\n textBagOfWords = cv.fit_transform(df['Text']).toarray()\\n textBagOfWords = pd.DataFrame(textBagOfWords)\\n df = df.drop(['Text'], axis = 1)\\n df = pd.concat([df, textBagOfWords], axis = 1)\\n return df\",\n \"def doc2idx(self, document, unknown_word_index=-1):\\n if isinstance(document, string_types):\\n raise TypeError(\\\"doc2idx expects an array of unicode tokens on input, not a single string\\\")\\n\\n document = [word if isinstance(word, unicode) else unicode(word, 'utf-8') for word in document]\\n return [self.token2id.get(word, unknown_word_index) for word in document]\",\n \"def bow(data_frame, description):\\n text = list(data_frame['article'])\\n vectorizer = CountVectorizer(stop_words='english') # create the transform\\n vectorizer.fit(text) # tokenize and build vocab\\n # save bow vectorizer as pickle\\n with open('resources/bow_encoder_' + description + '.pkl', 'wb') as f:\\n pickle.dump(vectorizer.vocabulary_, f)\\n f.close()\\n data_frame['bow'] = data_frame['article'].apply(lambda x: vectorizer.transform([x]))\\n return data_frame\",\n \"def extract_features(document):\\n document_words = set(document)\\n features = {}\\n global word_features\\t\\n for word in word_features:\\n features['contains(%s)' % word] = (word in document_words)\\n return features\",\n \"def q_tokenize(document):\\n final_words = []\\n avoided_words = [] # WORDS WHICH ARE TO BE AVOIDED IN THE FINAL LIST\\n \\n # making the avoided_words list\\n for word in string.punctuation: # the string library has a string of punctuations\\n avoided_words.append(word)\\n for word in nltk.corpus.stopwords.words(\\\"english\\\"): # the nltk lib. has a list of stopwords commonly used in english\\n avoided_words.append(word)\\n\\n tokens = nltk.word_tokenize(document)\",\n \"def wordbag( text, ignore_words = Ignore_words ) :\\n iter = (stripword(s) for s in text.lower().split() if stripword(s) not in ignore_words)\\n result = {}\\n for x in iter :\\n if result.has_key(x) :\\n result[x] += 1\\n else :\\n result[x] = 1\\n return result\",\n \"def bin_inscriptions(corpus):\\n doc_bin = DocBin(attrs=[\\\"LEMMA\\\",\\\"TAG\\\",\\\"POS\\\",\\\"DEP\\\",\\\"HEAD\\\"], store_user_data=True)\\n for c in corpus:\\n doc = nlp(c)\\n doc_bin.add(doc)\\n\\n with open('dbg.bin','wb') as f:\\n f.write(doc_bin.to_bytes())\",\n \"def get_words(doc):\\n splitter = re.compile('\\\\\\\\W*')\\n # Split the words by non-alpha characters\\n words = [s.lower() for s in splitter.split(doc) \\n if len(s)>2 and len(s)<20]\\n # Return the unique set of words only\\n return dict([(w,1) for w in words])\",\n \"def get_document_complexe_tags(self, document):\\n kw_extractor = yake.KeywordExtractor(lan=\\\"en\\\", n=3, top=30)\\n keywords = kw_extractor.extract_keywords(document)\\n\\n complexe_tag = []\\n for keyword in keywords:\\n if keyword[-1] >= 0.1:\\n break\\n complexe_tag.append(keyword[0])\\n return complexe_tag\",\n \"def get_terms(document):\\n q = get_mapped(document)\\n tokens = tockenizer(q)\\n terms = analizer(tokens)\\n\\n return terms\",\n \"def get_word_frequencies(documents):\\n cv_model = CountVectorizer(binary=True)\\n tf_matrix = cv_model.fit_transform(documents)\\n tf_matrix_transpose = tf_matrix.transpose()\\n\\n vocabulary = get_vocabulary(documents)\\n n_words = len(vocabulary)\\n\\n word_frequency = {}\\n word_frequency_in_documents = {}\\n\\n for word_idx in range(n_words):\\n word = vocabulary[word_idx]\\n tf_word = tf_matrix_transpose[word_idx]\\n\\n # getnnz -> Get the count of explicitly-stored values (nonzeros)\\n word_frequency[word] = float(tf_word.getnnz(1))\\n # nonzero -> Return the indices of the elements that are non-zero\\n word_frequency_in_documents[word] = set(tf_word.nonzero()[1])\\n\\n return word_frequency, word_frequency_in_documents\",\n \"def getBiwords(self, words):\\n bigrams_val = nltk.bigrams(words)\\n biwords = []\\n for word in bigrams_val:\\n biwords.append(word)\\n return biwords\",\n \"def pos_tag_counts(doc):\\n tags = []\\n for token in doc:\\n tags.append(token.pos_)\\n frequency = dict(Counter(tags).most_common()) \\n return frequency\",\n \"def _create_word_count_dict(self):\\n word_counts = dict()\\n for wc in self.word_counts.all():\\n word_counts[wc.word.name] = wc.count\\n return word_counts\",\n \"def get_tokens(self, document):\\n raise NotImplementedError()\",\n \"def entity_counts(doc):\\n \\n tags = []\\n for token in doc.ents:\\n tags.append(token.label_)\\n frequency = dict(Counter(tags).most_common())\\n\\n return frequency\",\n \"def test_bigrams():\\n tokenizer = Tokenizer(bigram_freq=0.5)\\n X = tokenizer.transform([[\\\"a b a b\\\"]])\\n assert X[\\\"corpus\\\"][0] == [\\\"a_b\\\", \\\"a_b\\\"]\\n assert isinstance(tokenizer.bigrams, pd.DataFrame)\",\n \"def preprocess_corpus(corpus, stop_list, stop_words=True, stemm=True, bag_words=True):\\n corpus_preprocessed = list()\\n for element in corpus:\\n new_element = dict()\\n new_element['document'] = preprocess_document(element['text'], stop_list, stop_words, stemm, bag_words)\\n new_element['id'] = element['id']\\n corpus_preprocessed.append(new_element)\\n\\n return corpus_preprocessed\",\n \"def learn_word_vocab(self, word_counts: typing.Counter[str]) -> Dict[str, int]:\\r\\n for token in set(self.required_tokens or []):\\r\\n word_counts[token] = int(2 ** 31)\\r\\n word_counts[self.PAD] = int(2 ** 32) # Make sure that PAD gets id=0\\r\\n sorted_word_counts = sorted(word_counts.items(), key=lambda p: -p[1])\\r\\n return {word: idx for idx, (word, count) in enumerate(sorted_word_counts[: self.word_vocab_size])}\",\n \"def clean_docs(self,docs):\\n\\n # Remove numbers, but not words that contain numbers.\\n docs = [[token for token in doc if not token.isnumeric()] for doc in docs]\\n\\n # Remove words that are only one character.\\n docs = [[token for token in doc if len(token) > 1 and token not in stop_words] for doc in docs]\\n\\n # lemmatizer = WordNetLemmatizer()\\n # docs = [[lemmatizer.lemmatize(token) for token in doc] for doc in docs]\\n\\n # Add bigrams and trigrams to docs (only ones that appear 20 times or more).\\n bigram = Phrases(docs, min_count=20)\\n for idx in range(len(docs)):\\n for token in bigram[docs[idx]]:\\n if '_' in token:\\n # Token is a bigram, add to document.\\n docs[idx].append(token)\\n\\n # Create a dictionary representation of the documents.\\n dictionary = Dictionary(docs)\\n\\n # Filter out words that occur less than 20 documents, or more than 50% of the documents.\\n dictionary.filter_extremes(no_below=20, no_above=0.5)\\n\\n # Bag-of-words representation of the documents.\\n corpus = [dictionary.doc2bow(doc) for doc in docs]\\n\\n return docs,dictionary,corpus\",\n \"def extractWordFeatures(x):\\n # BEGIN_YOUR_CODE (around 5 lines of code expected)\\n a = Counter(x.split())\\n return dict(a)\\n # END_YOUR_CODE\",\n \"def readDocument(self, filename, voc):\\n f = open(filename, encoding=\\\"utf8\\\")\\n text = f.read()\\n f.close()\\n table = str.maketrans(self.punct, \\\" \\\" * len(self.punct))\\n text = text.translate(table)\\n # Start with all zeros\\n bow = np.zeros(len(voc))\\n for w in text.split():\\n # If the word is the vocabulary...\\n if w in voc:\\n # ...increment the proper counter.\\n index = voc[w]\\n bow[index] += 1\\n return bow\",\n \"def features_extract(document, wordset):\\n words_doc = nltk.FreqDist(document)\\n features = []\\n for word in wordset:\\n features.append(words_doc[word])\\n return features\",\n \"def vectorize_doc_simple(self, doc):\\n\\n bow = defaultdict(float)\\n tokens = [token.lower() for token in doc.split()]\\n for token in tokens:\\n bow[token] += 1.0\\n return bow\",\n \"def word_tag_counts (count_file):\\r\\n wordtagcounts = defaultdict(list)\\r\\n f = open(count_file, 'r')\\r\\n for line in f:\\r\\n fields = line.split(\\\" \\\")\\r\\n if fields[1] != 'WORDTAG':\\r\\n continue\\r\\n count = int(fields[0].strip())\\r\\n tag = fields[2].strip()\\r\\n word = fields[3].strip()\\r\\n wordtagcounts[word].append((tag, count)) \\r\\n f.close() \\r\\n return wordtagcounts\",\n \"def get_feature_set_SB(tweet):\\n #pos-tag frequencies\\n# print \\\"Tagged words in tweet: \\\", tweet.tagged_words\\n pos_tag_freq = {}\\n additional_freq = {}\\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# if tag=='PRtinf':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJS':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJ':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='NP':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='DET':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='P':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n additional_freq['pronoun'] = 1\\n except KeyError:\\n continue\\n# print \\\"Tag frequencies: \\\", pos_tag_freq\\n for key in pos_tag_freq.keys():\\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \\n #Number of exclamation marks, number of emoticons,\\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\\n if emoticons>0:\\n additional_freq['emoticons'] = emoticons*1.0\\n if tweet.nrof_exclamations>0:\\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\\n \\n# print \\\"Additional frequencies: \\\", additional_freq\\n# raw_input(\\\"Continue?\\\")\\n \\n #Concatenate the dicts\\n features= dict(pos_tag_freq.items() + additional_freq.items())\\n# print \\\"All features: \\\", features\\n# raw_input(\\\"Continue?\\\")\\n return features\",\n \"def convert_corpus_to_lists(corpus_data):\\r\\n global ne_tags_set\\r\\n\\r\\n res_lsts = []\\r\\n for sent in corpus_data.iob_sents():\\r\\n if not sent:\\r\\n continue\\r\\n words, nes = [], []\\r\\n for tup in sent:\\r\\n words.append(tup[0])\\r\\n nes.append(tup[2])\\r\\n ne_tags_set.update(nes)\\r\\n res_lsts.append({'words': words, 'nes': nes})\\r\\n\\r\\n return res_lsts\",\n \"def count_words(data, number_word_frequency_results=40):\\n current_max_sentence_size = 0\\n count_word_frequency = Counter()\\n for entry in data:\\n print (entry)\\n terms_all = [term for term in entry]\\n count_word_frequency.update(terms_all)\\n return count_word_frequency.most_common(number_word_frequency_results)\",\n \"def create_tag_list(faker_obj, num=10):\\n fake = faker_obj\\n return fake.words(nb=num)\",\n \"def _get_bag_of_pos(words, index, N, target_len=1):\\n bos = DummyWord(pos=utils.BEGIN_OF_SENTENCE, upos=utils.BEGIN_OF_SENTENCE, dependency_relation=utils.BEGIN_OF_SENTENCE)\\n eos = DummyWord(pos=utils.END_OF_SENTENCE, upos=utils.END_OF_SENTENCE, dependency_relation=utils.END_OF_SENTENCE)\\n words = [bos] * N + words + [eos] * N\\n index += N\\n return [_get_word_feature(w) for w in words[index-N:index] + [words[index]] + words[index+target_len:index+target_len+N]]\",\n \"def bow2tfidf(doc_term_bow, corpus_tfidf):\\n doc_term_tfidf = corpus_tfidf[doc_term_bow]\\n scipy_tfidf = corpus2csc(doc_term_tfidf, num_terms = len(corpus_tfidf.idfs))\\n tfidf_mtx = csc_matrix(scipy_tfidf).T.toarray()\\n# print(f'The dimensions of tfidf matrix = {tfidf_mtx.shape}')\\n return tfidf_mtx\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75598925","0.67602545","0.64582515","0.63520515","0.5917524","0.5897528","0.58469146","0.5783915","0.5782803","0.5771413","0.57590044","0.5732742","0.5720406","0.57064784","0.5675183","0.5654374","0.5644353","0.5635149","0.55853426","0.5584801","0.5566225","0.555628","0.5548173","0.55473787","0.55292","0.5528124","0.55213606","0.5471837","0.54674333","0.54658204","0.54527575","0.54523855","0.5438297","0.5417862","0.5413706","0.54040253","0.5393506","0.5389471","0.5383417","0.53788805","0.5368723","0.5363487","0.53555876","0.5347967","0.53432435","0.5330719","0.53218395","0.5309028","0.528517","0.52717644","0.52702236","0.5257687","0.5254924","0.525368","0.5250891","0.52507746","0.52481055","0.5242255","0.52340275","0.52294236","0.52251196","0.5202333","0.5201033","0.51958776","0.5184707","0.5184477","0.5180649","0.5178058","0.5173469","0.51715237","0.5165607","0.5163354","0.51611555","0.5160638","0.5151979","0.51505786","0.51467514","0.5138188","0.5129542","0.5125597","0.51245016","0.5117293","0.5112767","0.51117134","0.51110995","0.5109514","0.5105078","0.50954574","0.5092957","0.5082291","0.5079884","0.50798035","0.507229","0.50709724","0.5067233","0.5066023","0.50621605","0.50613314","0.50601083","0.50592107"],"string":"[\n \"0.75598925\",\n \"0.67602545\",\n \"0.64582515\",\n \"0.63520515\",\n \"0.5917524\",\n \"0.5897528\",\n \"0.58469146\",\n \"0.5783915\",\n \"0.5782803\",\n \"0.5771413\",\n \"0.57590044\",\n \"0.5732742\",\n \"0.5720406\",\n \"0.57064784\",\n \"0.5675183\",\n \"0.5654374\",\n \"0.5644353\",\n \"0.5635149\",\n \"0.55853426\",\n \"0.5584801\",\n \"0.5566225\",\n \"0.555628\",\n \"0.5548173\",\n \"0.55473787\",\n \"0.55292\",\n \"0.5528124\",\n \"0.55213606\",\n \"0.5471837\",\n \"0.54674333\",\n \"0.54658204\",\n \"0.54527575\",\n \"0.54523855\",\n \"0.5438297\",\n \"0.5417862\",\n \"0.5413706\",\n \"0.54040253\",\n \"0.5393506\",\n \"0.5389471\",\n \"0.5383417\",\n \"0.53788805\",\n \"0.5368723\",\n \"0.5363487\",\n \"0.53555876\",\n \"0.5347967\",\n \"0.53432435\",\n \"0.5330719\",\n \"0.53218395\",\n \"0.5309028\",\n \"0.528517\",\n \"0.52717644\",\n \"0.52702236\",\n \"0.5257687\",\n \"0.5254924\",\n \"0.525368\",\n \"0.5250891\",\n \"0.52507746\",\n \"0.52481055\",\n \"0.5242255\",\n \"0.52340275\",\n \"0.52294236\",\n \"0.52251196\",\n \"0.5202333\",\n \"0.5201033\",\n \"0.51958776\",\n \"0.5184707\",\n \"0.5184477\",\n \"0.5180649\",\n \"0.5178058\",\n \"0.5173469\",\n \"0.51715237\",\n \"0.5165607\",\n \"0.5163354\",\n \"0.51611555\",\n \"0.5160638\",\n \"0.5151979\",\n \"0.51505786\",\n \"0.51467514\",\n \"0.5138188\",\n \"0.5129542\",\n \"0.5125597\",\n \"0.51245016\",\n \"0.5117293\",\n \"0.5112767\",\n \"0.51117134\",\n \"0.51110995\",\n \"0.5109514\",\n \"0.5105078\",\n \"0.50954574\",\n \"0.5092957\",\n \"0.5082291\",\n \"0.5079884\",\n \"0.50798035\",\n \"0.507229\",\n \"0.50709724\",\n \"0.5067233\",\n \"0.5066023\",\n \"0.50621605\",\n \"0.50613314\",\n \"0.50601083\",\n \"0.50592107\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6443913"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":7387,"cells":{"query":{"kind":"string","value":"Get the token_id of given token."},"document":{"kind":"string","value":"def token_to_id(self, token):\n token = self.process_token(token)\n return self.token2id.get(token, len(self.token2id) - 1)"},"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 token_to_id(self, token):\n token = self.process_token(token)\n return self._token2id.get(token, len(self._token2id) - 1)","def token_to_id(self, token):\r\n return self.encoder.get(token, self.encoder.get(self.unk_token))","def token_id(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"token_id\")","def map_token_to_id(self, token: str):\n if token not in self._token_to_id:\n token = self._unk_token\n return self._token_to_id[token]","def token_id(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"token_id\")","def _convert_token_to_id(self, token):\n return self.vocab.get(token, self.vocab.get(self.unk_token))","def _convert_token_to_id(self, token):\n return self.sp_model.PieceToId(str(token))","def _convert_token_to_id(self, token):\n return self.sp_model.PieceToId(token)","def _convert_token_to_id(self, token):\n if token in self.fairseq_tokens_to_ids:\n return self.fairseq_tokens_to_ids[token]\n spm_id = self.sp_model.PieceToId(token)\n\n # Need to return unknown token if the SP model returned 0\n return spm_id + self.fairseq_offset if spm_id else self.unk_token_id","def get_token(self, token_id):\n raise exception.NotImplemented() # pragma: no cover","def try_get_user_id_from_token(token):\n dot_index = token.find('.')\n if (dot_index > 0):\n token_base64 = token[:dot_index]\n \n try:\n token_string = b64decode(token_base64)\n except Base64DecodeError:\n user_id = 0\n else:\n try:\n user_id = int(token_string)\n except ValueError:\n user_id = 0\n else:\n user_id = 0\n \n return user_id","def token(cls, token):\n user_db = User.get_by('token', token)\n if not user_db:\n raise ValueError('Sorry, your token is either invalid or expired.')\n return token","def get_token(self):\n token = self._session.token\n return token","def get_user_id(jwt_token):\n return (\n jwt_token.payload[\"user\"].get(\"id\")\n if jwt_token.payload.get(\"user\")\n else jwt_token.payload[\"session_id\"]\n )","def token(self):\n return self[\"token\"]","def LookupToken(self, dmtoken):\n self.ReadClientStateFile()\n return self._registered_tokens.get(dmtoken, None)","def _get_auth_token(self):\n\n __logger__.debug(\"Getting auth Token\")\n return self.keystone_client.auth_ref['token']['id']","def vpp_token_id(self):\n if \"vppTokenId\" in self._prop_dict:\n return self._prop_dict[\"vppTokenId\"]\n else:\n return None","def get_token(self):\n token_model = TokenModel.find_by_user_id(self.id)\n return token_model.token if token_model else None","def verify_token(self, token: str) -> str:\n return decode(self.rd.hget(\"auth:by_token\", token))","def get_token_id(self):\n return f\"{self.document_title}_{self.index}\"","def get_current_uid():\n # TODO: Find a better way to access the token\n return request.token['id']","def get_token(self):\n\n return self._token","def get_token(self):\n return self.__token","def get_token(self):\n return self.__token","def get(uid: int, token_id: int):\n\n token = Token.get(uid, token_id).as_dto().to_primitive()\n\n if token:\n return token.to_primitive()\n else:\n raise NotFound(\"Token Not Found\")","def token(self) -> str:\n return pulumi.get(self, \"token\")","def token(self) -> str:\n return pulumi.get(self, \"token\")","def token(self) -> str:\n return pulumi.get(self, \"token\")","def token():\n return os.environ.get('TOKEN', None)","def token(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"token\")","def token(self):\n return self._token","def token(self):\n return self._token","def token(self):\n return self._token","def spotify_id_from_token(access_token: str) -> Optional[str]:\n if access_token is None:\n return None\n headers = {\"Authorization\": \"Bearer {}\".format(access_token)}\n response = requests.post(\"https://api.spotify.com/v1/me\", headers=headers)\n if response.status_code != 200:\n return None\n user = response.json()\n if \"id\" not in user:\n return None\n return user[\"id\"]","async def get_user_id(conn, login=None, token=None):\n if login:\n query = db.users.select().where(db.users.c.login == login)\n user = await conn.fetch(query)\n if len(user) == 0:\n return None\n else:\n query = db.users.select().where(db.users.c.token == token)\n user = await conn.fetch(query)\n return user[0]['id']","def token(self):\r\n return self._token","async def get_user_token(\n token: Optional[str] = None,\n x_token: Optional[str] = Header(None),\n authorization: Optional[str] = Header(None),\n sessiontoken: Optional[str] = Cookie(None),\n) -> Optional[str]:\n if token:\n return token\n if x_token:\n return x_token\n if authorization and authorization.startswith(\"Bearer \"):\n return authorization[7:]\n if sessiontoken:\n return sessiontoken\n return None","def token(self):\n\n if not self.requests:\n return None\n return self.requests[0].token","def get_jwt_identity(self) -> Optional[Union[str,int]]:\n if self._TOKEN:\n return self._verified_token(encoded_token=self._TOKEN)['identity']\n return None","def _handle_token(self, token: str) -> Optional[str]:\n return token or self._token_handler.token","def verify_token(token):\n return AuthToken.query.filter_by(auth_token=token).first()","def getToken(self):\n query = \"SELECT token FROM token WHERE id = 1\"\n res = self.db.execute(query).fetchone()\n if res:\n return res[0]\n return False","def getToken():\n token = getenv(TOKEN_NAME)\n if token == None:\n raise SystemExit('No token found. Use env variable %s' % TOKEN_NAME)\n return token","def get_token(self, tid):\n if self.lliagraph:\n return self.lliagraph.get_token(tid)\n else:\n return None","def token_id_hex(self) -> str: # this is *ALSO* a MINT property\n return self.token_id.hex()","def _get_token(self):\n return user.get_token()","def decode_token(token):\n payload = None\n try:\n payload = jwt.decode(token.encode('utf-8'), '1$Arh\"1bWa/7+OS', algorithm='HS256')['u_id']\n except jwt.InvalidTokenError:\n pass\n return payload","def id(self, tokens):\n if len(tokens) != 1:\n raise Exception(\"Unexpected argument counts\")\n return tokens[0].value","def get_token():\n params = {'get_token': 'get_token'}\n return load_page(API, params=params, headers={'content-type': 'application/json'})['token']","def get_token(self, token_file: str = 'token') -> str:\n token = ''\n with open(self.path(token_file), 'r') as file:\n tokens = file.read().split('\\n')\n # Loop over all tokens in the file\n for t in tokens:\n # Check if name of token matches name of bot\n if self.name in t:\n token = t.split(' ')[1]\n return token","def _handle_token(self, token: str) -> Optional[str]:\n return token","def get_token(self, organization_id: int, provider: str) -> str | None:\n sentry_app_installation_tokens = self.select_related(\"api_token\").filter(\n sentry_app_installation__sentryappinstallationforprovider__organization_id=organization_id,\n sentry_app_installation__sentryappinstallationforprovider__provider=provider,\n )\n if not sentry_app_installation_tokens:\n return None\n\n return sentry_app_installation_tokens[0].api_token.token","def _get_token(token=None):\n if token is not None:\n return token\n else:\n return os.environ.get(\"MAPBOX_ACCESS_TOKEN\") or os.environ.get(\n \"MapboxAccessToken\"\n )","def find_auth_token(document_html):\n search_result = re.search(AUTH_TOKEN_REGEX, document_html)\n if search_result:\n return search_result.group('auth_token')","def identifier(self) -> str:\n return self.current_token","def token(self) -> Optional[str]:\n return self._builder._token","def get_username_from_token(self, token):\n dataBase = self.read_database()\n if token in dataBase['sessions']:\n userName = dataBase['sessions'][token]['userName']\n return userName\n else:\n raise InvalidTokenException(\"Token not valid.\")","def get_token():\n return session.get('microsoft_token')","def get_token():\n return session.get('microsoft_token')","def decode_token(token):\n try:\n # try to decode the token using our SECRET variable\n payload = jwt.decode(token, app.config.get('SECRET_KEY'), algorithms=['HS256'])\n return payload['sub']\n except jwt.ExpiredSignatureError:\n # the token is expired, return an error string\n return \"Expired token. Please login to get a new token\"\n except jwt.InvalidTokenError:\n # the token is invalid, return an error string\n return \"Invalid token. Please register or login\"","def decode_token(token):\n try:\n payload = jwt.decode(\n token, app.config.get('SECRET_KEY'), algorithms='HS256')\n return payload['sub']\n except jwt.ExpiredSignatureError:\n return \"Expired token. Please login to get a new token\"\n except jwt.InvalidTokenError:\n return \"Invalid token. Please register or login\"","def get(self, token):\n args = (token, )\n row = self.db_manager.execute_sql_and_fetchone(SQL_TOKEN_GET, args)\n if row:\n token_object = convert_db_row_to_dict(row, TOKEN_MODEL_FIELDS)\n else:\n token_object = {}\n return token_object","def decode_token(token):\n try:\n # Decode token with our secret key\n payload = jwt.decode(token, SECRET_KEY)\n return payload['sub']\n except jwt.ExpiredSignatureError:\n # token has expired\n return \"Timed out. Please login to get a new token\"\n except jwt.InvalidTokenError:\n return \"Invalid token. Please register or login\"","def find_token_for_authorization(authorization):\n return None","def get_token(filename='config.ini'):\n cp = ConfigParser()\n cp.read(filename)\n token = cp.get('githubapi', 'token')\n return token","def token_key(token):\n morphotagged = analysis(token).get('raw')\n lemma_pos = (analysis(token).get('lemma'), analysis(token).get('partOfSpeech'))\n return morphotagged or lemma_pos","def check_token(token):\n return conn.hget('login:', token)","def map_id_to_token(self, id: int):\n return self._id_to_token[id]","def get_token(self):\n if not self.is_valid():\n logger.warn(\"TokenWall form data is not valid.\")\n return None\n \n tt = self.cleaned_data['token']\n logger.debug(\"Looking for token '%s'\"%tt)\n return Token.objects.get(value=tt)","def get_token_auth_header():\n auth = request.headers.get(\"Authorization\", None)\n if not auth:\n return \"authorization_header_missing\"\n\n parts = auth.split()\n\n if parts[0].lower() != \"bearer\":\n return \"invalid_header\"\n elif len(parts) == 1:\n return \"invalid_header\"\n elif len(parts) > 2:\n return \"invalid_header\"\n\n token = parts[1]\n return token","def token(self):\n print(\"getter of token called\")\n return self._token","def get_auth_token():\n if CFG.auth_enabled:\n auth_token = get_keystone_token()\n else:\n auth_token = 'notrealtoken'\n\n return auth_token","def token(self):\n if not self._token:\n self._token = self.authenicate().token\n\n return self._token","def validate_token(self, token):\n from expfactory.database.models import Participant\n\n p = Participant.query.filter(Participant.token == token).first()\n if p is not None:\n if p.token.endswith((\"finished\", \"revoked\")):\n p = None\n else:\n p = p.id\n return p","def get_token_auth_header():\n auth = request.headers.get(\"Authorization\", None)\n if not auth:\n raise AuthError({\"code\": \"authorization_header_missing\",\n \"description\":\n \"Authorization header is expected\"}, 401)\n\n parts = auth.split()\n\n if parts[0].lower() != \"bearer\":\n raise AuthError({\"code\": \"invalid_header\",\n \"description\":\n \"Authorization header must start with\"\n \" Bearer\"}, 401)\n elif len(parts) == 1:\n raise AuthError({\"code\": \"invalid_header\",\n \"description\": \"Token not found\"}, 401)\n elif len(parts) > 2:\n raise AuthError({\"code\": \"invalid_header\",\n \"description\":\n \"Authorization header must be\"\n \" Bearer token\"}, 401)\n\n token = parts[1]\n return token","async def token(request: Request):\n return get_token()","def token(self):\n\n return self.__token","def validate_token(self, token):\n\n try:\n if not token:\n raise AuthException(\"Needed a token or Authorization HTTP header\", http_code=HTTPStatus.UNAUTHORIZED)\n\n # try to get from cache first\n now = time()\n token_info = self.token_cache.get(token)\n if token_info and token_info[\"expires\"] < now:\n # delete token. MUST be done with care, as another thread maybe already delete it. Do not use del\n self.token_cache.pop(token, None)\n token_info = None\n\n # get from database if not in cache\n if not token_info:\n token_info = self.db.get_one(\"tokens\", {\"_id\": token})\n if token_info[\"expires\"] < now:\n raise AuthException(\"Expired Token or Authorization HTTP header\", http_code=HTTPStatus.UNAUTHORIZED)\n\n return token_info\n\n except DbException as e:\n if e.http_code == HTTPStatus.NOT_FOUND:\n raise AuthException(\"Invalid Token or Authorization HTTP header\", http_code=HTTPStatus.UNAUTHORIZED)\n else:\n raise\n except AuthException:\n if self.config[\"global\"].get(\"test.user_not_authorized\"):\n return {\"id\": \"fake-token-id-for-test\",\n \"project_id\": self.config[\"global\"].get(\"test.project_not_authorized\", \"admin\"),\n \"username\": self.config[\"global\"][\"test.user_not_authorized\"], \"admin\": True}\n else:\n raise\n except Exception:\n self.logger.exception(\"Error during token validation using internal backend\")\n raise AuthException(\"Error during token validation using internal backend\",\n http_code=HTTPStatus.UNAUTHORIZED)","def _parse_token(self, body):\n\n token_match = re.search('var\\s*token\\s*=[\\s\\']*(\\d+)', body)\n return int(token_match.group(1))","def get_current_pub_key(token: str = Depends(token_header)):\n return decode_token(token)","def verify_auth_token(token):\n serializer = Serializer(SECRET_KEY)\n try:\n data = serializer.loads(token)\n except SignatureExpired:\n return None # valid token, but expired\n except BadSignature:\n return None # invalid token\n return data['token']","def get_token(self):\n\n try:\n return jwt.decode(self.fetch_token(), KEY, algorithms=['HS256'])\n except jwt.exceptions.DecodeError:\n raise InvalidToken","def token(self) -> Token:\n return getattr(self, \"tok\", None)","def get_token_auth_header():\n auth = request.headers.get(\"Authorization\", None)\n print(auth)\n\n if not auth:\n raise AuthError({\"code\": \"authorization_header_missing\",\n \"description\":\n \"Authorization header is expected\"}, 401)\n \n parts = auth.split()\n \n if parts[0].lower() != \"bearer\":\n raise AuthError({\"code\": \"invalid_header\",\n \"description\":\n \"Authorization header must start with\"\n \" Bearer\"}, 401)\n elif len(parts) == 1:\n raise AuthError({\"code\": \"invalid_header\",\n \"description\": \"Token not found\"}, 401)\n elif len(parts) > 2:\n raise AuthError({\"code\": \"invalid_header\",\n \"description\":\n \"Authorization header must be\"\n \" Bearer token\"}, 401)\n\n token = parts[1]\n return token","def get_token_auth_header():\n auth = request.headers.get('Authorization', None)\n if not auth:\n raise AuthError({'code': 'authorization_header_missing',\n 'description': 'Authorization header is expected'}, 401)\n\n parts = auth.split()\n\n if parts[0].lower() != 'bearer':\n raise AuthError({'code': 'invalid_header',\n 'description': 'Authorization header must start with Bearer'}, 401)\n\n if len(parts) < 2:\n raise AuthError({'code': 'invalid_header',\n 'description': 'Token not found after Bearer'}, 401)\n\n if len(parts) > 2:\n raise AuthError({'code': 'invalid_header',\n 'description': 'Authorization header is an invalid token structure'}, 401)\n\n return parts[1]","def process_id_from(self):\r\n return self._tokens[1]","def get_token_auth_header():\n auth = request.headers.get('Authorization', None)\n if not auth:\n raise AuthError({\n 'code': 'authorization_header_missing',\n 'description': 'Authorization header is expected.'\n }, 401)\n\n parts = auth.split()\n if parts[0].lower() != 'bearer':\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must start with \"Bearer\".'\n }, 401)\n\n elif len(parts) == 1:\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Token not found.'\n }, 401)\n\n elif len(parts) > 2:\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must be bearer token.'\n }, 401)\n\n token = parts[1]\n return token","def get_token(headers):\n bearer = headers.get('Authorization')\n if bearer:\n try:\n token_type, token = bearer.rsplit(' ', 1)\n except ValueError:\n raise TokenError('Wrong bearer string: %s', bearer)\n\n if token_type != 'Bearer':\n raise TokenError('Wrong token type: %s, must be %s',\n token_type, 'Bearer')\n return token\n raise TokenError('No token is given in the Authorization header')","def _get_token(self): # pragma: no cover\n\n tokenCookie = None\n for cookie in self._session.cookies:\n if \"mast_token\" in cookie.name:\n tokenCookie = cookie\n break\n\n if not tokenCookie:\n warnings.warn(\"No auth token found.\", AuthenticationWarning)\n\n return tokenCookie","def parse_token(token):\n return jwt.decode(token, app.config['JWT_SECRET'])","async def get_user_token_strict(token: Optional[str] = Depends(get_user_token)) -> str:\n if token:\n return token\n raise exceptions.AuthenticationException()","def get_token():\n # get authorization header:\n auth = request.headers.get('Authorization', None)\n \n # authorization header should be included:\n if auth is None:\n raise JWTError(\n {\n 'code': 'authorization_header_missing',\n 'description': 'Authorization header is expected.'\n }, \n 401\n )\n \n # authorization header should be 'Bearer [JWT]'\n parts = auth.split()\n if parts[0].lower() != 'bearer':\n raise JWTError(\n {\n 'code': 'invalid_header',\n 'description': 'Authorization header must start with \"Bearer\".'\n }, \n 401\n )\n elif len(parts) == 1:\n raise JWTError(\n {\n 'code': 'invalid_header',\n 'description': 'Token not found.'\n }, \n 401\n )\n elif len(parts) > 2:\n raise JWTError(\n {\n 'code': 'invalid_header',\n 'description': 'Authorization header must be bearer token.'\n }, \n 401\n )\n\n # extract JWT:\n token = parts[1]\n\n return token","def retrieve_token(filename):\n with open(filename, 'r') as f:\n token = f.readline()\n\n return token","def getToken(request):\n try:\n token = request.META['HTTP_AUTHORIZATION'].split()[1]\n except:\n token = \"\"\n return token","def _get_token(self) -> str:\n if IS_SUPERVISOR:\n # On supervisor installs the token is provided by a environment variable\n return os.environ[\"HASSIO_TOKEN\"]\n return self._token","def prep_token(**kwargs):\n token = kwargs.get('token')\n if not token:\n token = oauth2_wrappers.gen_token()\n return token","def get_task_token(decision):\n try:\n return decision[\"taskToken\"]\n except KeyError:\n # No taskToken returned\n return None","def get_id(self, word, add=False):\n if word not in self.word_to_id:\n if add:\n self._add_new_word(word)\n return self.word_to_id[constants.UNK_TOKEN]\n return self.word_to_id[word]","def get_token(self): # pragma: no cover\n\t\treturn (session.get(\"access_token\"), \"\")"],"string":"[\n \"def token_to_id(self, token):\\n token = self.process_token(token)\\n return self._token2id.get(token, len(self._token2id) - 1)\",\n \"def token_to_id(self, token):\\r\\n return self.encoder.get(token, self.encoder.get(self.unk_token))\",\n \"def token_id(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"token_id\\\")\",\n \"def map_token_to_id(self, token: str):\\n if token not in self._token_to_id:\\n token = self._unk_token\\n return self._token_to_id[token]\",\n \"def token_id(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"token_id\\\")\",\n \"def _convert_token_to_id(self, token):\\n return self.vocab.get(token, self.vocab.get(self.unk_token))\",\n \"def _convert_token_to_id(self, token):\\n return self.sp_model.PieceToId(str(token))\",\n \"def _convert_token_to_id(self, token):\\n return self.sp_model.PieceToId(token)\",\n \"def _convert_token_to_id(self, token):\\n if token in self.fairseq_tokens_to_ids:\\n return self.fairseq_tokens_to_ids[token]\\n spm_id = self.sp_model.PieceToId(token)\\n\\n # Need to return unknown token if the SP model returned 0\\n return spm_id + self.fairseq_offset if spm_id else self.unk_token_id\",\n \"def get_token(self, token_id):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def try_get_user_id_from_token(token):\\n dot_index = token.find('.')\\n if (dot_index > 0):\\n token_base64 = token[:dot_index]\\n \\n try:\\n token_string = b64decode(token_base64)\\n except Base64DecodeError:\\n user_id = 0\\n else:\\n try:\\n user_id = int(token_string)\\n except ValueError:\\n user_id = 0\\n else:\\n user_id = 0\\n \\n return user_id\",\n \"def token(cls, token):\\n user_db = User.get_by('token', token)\\n if not user_db:\\n raise ValueError('Sorry, your token is either invalid or expired.')\\n return token\",\n \"def get_token(self):\\n token = self._session.token\\n return token\",\n \"def get_user_id(jwt_token):\\n return (\\n jwt_token.payload[\\\"user\\\"].get(\\\"id\\\")\\n if jwt_token.payload.get(\\\"user\\\")\\n else jwt_token.payload[\\\"session_id\\\"]\\n )\",\n \"def token(self):\\n return self[\\\"token\\\"]\",\n \"def LookupToken(self, dmtoken):\\n self.ReadClientStateFile()\\n return self._registered_tokens.get(dmtoken, None)\",\n \"def _get_auth_token(self):\\n\\n __logger__.debug(\\\"Getting auth Token\\\")\\n return self.keystone_client.auth_ref['token']['id']\",\n \"def vpp_token_id(self):\\n if \\\"vppTokenId\\\" in self._prop_dict:\\n return self._prop_dict[\\\"vppTokenId\\\"]\\n else:\\n return None\",\n \"def get_token(self):\\n token_model = TokenModel.find_by_user_id(self.id)\\n return token_model.token if token_model else None\",\n \"def verify_token(self, token: str) -> str:\\n return decode(self.rd.hget(\\\"auth:by_token\\\", token))\",\n \"def get_token_id(self):\\n return f\\\"{self.document_title}_{self.index}\\\"\",\n \"def get_current_uid():\\n # TODO: Find a better way to access the token\\n return request.token['id']\",\n \"def get_token(self):\\n\\n return self._token\",\n \"def get_token(self):\\n return self.__token\",\n \"def get_token(self):\\n return self.__token\",\n \"def get(uid: int, token_id: int):\\n\\n token = Token.get(uid, token_id).as_dto().to_primitive()\\n\\n if token:\\n return token.to_primitive()\\n else:\\n raise NotFound(\\\"Token Not Found\\\")\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def token():\\n return os.environ.get('TOKEN', None)\",\n \"def token(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def token(self):\\n return self._token\",\n \"def token(self):\\n return self._token\",\n \"def token(self):\\n return self._token\",\n \"def spotify_id_from_token(access_token: str) -> Optional[str]:\\n if access_token is None:\\n return None\\n headers = {\\\"Authorization\\\": \\\"Bearer {}\\\".format(access_token)}\\n response = requests.post(\\\"https://api.spotify.com/v1/me\\\", headers=headers)\\n if response.status_code != 200:\\n return None\\n user = response.json()\\n if \\\"id\\\" not in user:\\n return None\\n return user[\\\"id\\\"]\",\n \"async def get_user_id(conn, login=None, token=None):\\n if login:\\n query = db.users.select().where(db.users.c.login == login)\\n user = await conn.fetch(query)\\n if len(user) == 0:\\n return None\\n else:\\n query = db.users.select().where(db.users.c.token == token)\\n user = await conn.fetch(query)\\n return user[0]['id']\",\n \"def token(self):\\r\\n return self._token\",\n \"async def get_user_token(\\n token: Optional[str] = None,\\n x_token: Optional[str] = Header(None),\\n authorization: Optional[str] = Header(None),\\n sessiontoken: Optional[str] = Cookie(None),\\n) -> Optional[str]:\\n if token:\\n return token\\n if x_token:\\n return x_token\\n if authorization and authorization.startswith(\\\"Bearer \\\"):\\n return authorization[7:]\\n if sessiontoken:\\n return sessiontoken\\n return None\",\n \"def token(self):\\n\\n if not self.requests:\\n return None\\n return self.requests[0].token\",\n \"def get_jwt_identity(self) -> Optional[Union[str,int]]:\\n if self._TOKEN:\\n return self._verified_token(encoded_token=self._TOKEN)['identity']\\n return None\",\n \"def _handle_token(self, token: str) -> Optional[str]:\\n return token or self._token_handler.token\",\n \"def verify_token(token):\\n return AuthToken.query.filter_by(auth_token=token).first()\",\n \"def getToken(self):\\n query = \\\"SELECT token FROM token WHERE id = 1\\\"\\n res = self.db.execute(query).fetchone()\\n if res:\\n return res[0]\\n return False\",\n \"def getToken():\\n token = getenv(TOKEN_NAME)\\n if token == None:\\n raise SystemExit('No token found. Use env variable %s' % TOKEN_NAME)\\n return token\",\n \"def get_token(self, tid):\\n if self.lliagraph:\\n return self.lliagraph.get_token(tid)\\n else:\\n return None\",\n \"def token_id_hex(self) -> str: # this is *ALSO* a MINT property\\n return self.token_id.hex()\",\n \"def _get_token(self):\\n return user.get_token()\",\n \"def decode_token(token):\\n payload = None\\n try:\\n payload = jwt.decode(token.encode('utf-8'), '1$Arh\\\"1bWa/7+OS', algorithm='HS256')['u_id']\\n except jwt.InvalidTokenError:\\n pass\\n return payload\",\n \"def id(self, tokens):\\n if len(tokens) != 1:\\n raise Exception(\\\"Unexpected argument counts\\\")\\n return tokens[0].value\",\n \"def get_token():\\n params = {'get_token': 'get_token'}\\n return load_page(API, params=params, headers={'content-type': 'application/json'})['token']\",\n \"def get_token(self, token_file: str = 'token') -> str:\\n token = ''\\n with open(self.path(token_file), 'r') as file:\\n tokens = file.read().split('\\\\n')\\n # Loop over all tokens in the file\\n for t in tokens:\\n # Check if name of token matches name of bot\\n if self.name in t:\\n token = t.split(' ')[1]\\n return token\",\n \"def _handle_token(self, token: str) -> Optional[str]:\\n return token\",\n \"def get_token(self, organization_id: int, provider: str) -> str | None:\\n sentry_app_installation_tokens = self.select_related(\\\"api_token\\\").filter(\\n sentry_app_installation__sentryappinstallationforprovider__organization_id=organization_id,\\n sentry_app_installation__sentryappinstallationforprovider__provider=provider,\\n )\\n if not sentry_app_installation_tokens:\\n return None\\n\\n return sentry_app_installation_tokens[0].api_token.token\",\n \"def _get_token(token=None):\\n if token is not None:\\n return token\\n else:\\n return os.environ.get(\\\"MAPBOX_ACCESS_TOKEN\\\") or os.environ.get(\\n \\\"MapboxAccessToken\\\"\\n )\",\n \"def find_auth_token(document_html):\\n search_result = re.search(AUTH_TOKEN_REGEX, document_html)\\n if search_result:\\n return search_result.group('auth_token')\",\n \"def identifier(self) -> str:\\n return self.current_token\",\n \"def token(self) -> Optional[str]:\\n return self._builder._token\",\n \"def get_username_from_token(self, token):\\n dataBase = self.read_database()\\n if token in dataBase['sessions']:\\n userName = dataBase['sessions'][token]['userName']\\n return userName\\n else:\\n raise InvalidTokenException(\\\"Token not valid.\\\")\",\n \"def get_token():\\n return session.get('microsoft_token')\",\n \"def get_token():\\n return session.get('microsoft_token')\",\n \"def decode_token(token):\\n try:\\n # try to decode the token using our SECRET variable\\n payload = jwt.decode(token, app.config.get('SECRET_KEY'), algorithms=['HS256'])\\n return payload['sub']\\n except jwt.ExpiredSignatureError:\\n # the token is expired, return an error string\\n return \\\"Expired token. Please login to get a new token\\\"\\n except jwt.InvalidTokenError:\\n # the token is invalid, return an error string\\n return \\\"Invalid token. Please register or login\\\"\",\n \"def decode_token(token):\\n try:\\n payload = jwt.decode(\\n token, app.config.get('SECRET_KEY'), algorithms='HS256')\\n return payload['sub']\\n except jwt.ExpiredSignatureError:\\n return \\\"Expired token. Please login to get a new token\\\"\\n except jwt.InvalidTokenError:\\n return \\\"Invalid token. Please register or login\\\"\",\n \"def get(self, token):\\n args = (token, )\\n row = self.db_manager.execute_sql_and_fetchone(SQL_TOKEN_GET, args)\\n if row:\\n token_object = convert_db_row_to_dict(row, TOKEN_MODEL_FIELDS)\\n else:\\n token_object = {}\\n return token_object\",\n \"def decode_token(token):\\n try:\\n # Decode token with our secret key\\n payload = jwt.decode(token, SECRET_KEY)\\n return payload['sub']\\n except jwt.ExpiredSignatureError:\\n # token has expired\\n return \\\"Timed out. Please login to get a new token\\\"\\n except jwt.InvalidTokenError:\\n return \\\"Invalid token. Please register or login\\\"\",\n \"def find_token_for_authorization(authorization):\\n return None\",\n \"def get_token(filename='config.ini'):\\n cp = ConfigParser()\\n cp.read(filename)\\n token = cp.get('githubapi', 'token')\\n return token\",\n \"def token_key(token):\\n morphotagged = analysis(token).get('raw')\\n lemma_pos = (analysis(token).get('lemma'), analysis(token).get('partOfSpeech'))\\n return morphotagged or lemma_pos\",\n \"def check_token(token):\\n return conn.hget('login:', token)\",\n \"def map_id_to_token(self, id: int):\\n return self._id_to_token[id]\",\n \"def get_token(self):\\n if not self.is_valid():\\n logger.warn(\\\"TokenWall form data is not valid.\\\")\\n return None\\n \\n tt = self.cleaned_data['token']\\n logger.debug(\\\"Looking for token '%s'\\\"%tt)\\n return Token.objects.get(value=tt)\",\n \"def get_token_auth_header():\\n auth = request.headers.get(\\\"Authorization\\\", None)\\n if not auth:\\n return \\\"authorization_header_missing\\\"\\n\\n parts = auth.split()\\n\\n if parts[0].lower() != \\\"bearer\\\":\\n return \\\"invalid_header\\\"\\n elif len(parts) == 1:\\n return \\\"invalid_header\\\"\\n elif len(parts) > 2:\\n return \\\"invalid_header\\\"\\n\\n token = parts[1]\\n return token\",\n \"def token(self):\\n print(\\\"getter of token called\\\")\\n return self._token\",\n \"def get_auth_token():\\n if CFG.auth_enabled:\\n auth_token = get_keystone_token()\\n else:\\n auth_token = 'notrealtoken'\\n\\n return auth_token\",\n \"def token(self):\\n if not self._token:\\n self._token = self.authenicate().token\\n\\n return self._token\",\n \"def validate_token(self, token):\\n from expfactory.database.models import Participant\\n\\n p = Participant.query.filter(Participant.token == token).first()\\n if p is not None:\\n if p.token.endswith((\\\"finished\\\", \\\"revoked\\\")):\\n p = None\\n else:\\n p = p.id\\n return p\",\n \"def get_token_auth_header():\\n auth = request.headers.get(\\\"Authorization\\\", None)\\n if not auth:\\n raise AuthError({\\\"code\\\": \\\"authorization_header_missing\\\",\\n \\\"description\\\":\\n \\\"Authorization header is expected\\\"}, 401)\\n\\n parts = auth.split()\\n\\n if parts[0].lower() != \\\"bearer\\\":\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\":\\n \\\"Authorization header must start with\\\"\\n \\\" Bearer\\\"}, 401)\\n elif len(parts) == 1:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\": \\\"Token not found\\\"}, 401)\\n elif len(parts) > 2:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\":\\n \\\"Authorization header must be\\\"\\n \\\" Bearer token\\\"}, 401)\\n\\n token = parts[1]\\n return token\",\n \"async def token(request: Request):\\n return get_token()\",\n \"def token(self):\\n\\n return self.__token\",\n \"def validate_token(self, token):\\n\\n try:\\n if not token:\\n raise AuthException(\\\"Needed a token or Authorization HTTP header\\\", http_code=HTTPStatus.UNAUTHORIZED)\\n\\n # try to get from cache first\\n now = time()\\n token_info = self.token_cache.get(token)\\n if token_info and token_info[\\\"expires\\\"] < now:\\n # delete token. MUST be done with care, as another thread maybe already delete it. Do not use del\\n self.token_cache.pop(token, None)\\n token_info = None\\n\\n # get from database if not in cache\\n if not token_info:\\n token_info = self.db.get_one(\\\"tokens\\\", {\\\"_id\\\": token})\\n if token_info[\\\"expires\\\"] < now:\\n raise AuthException(\\\"Expired Token or Authorization HTTP header\\\", http_code=HTTPStatus.UNAUTHORIZED)\\n\\n return token_info\\n\\n except DbException as e:\\n if e.http_code == HTTPStatus.NOT_FOUND:\\n raise AuthException(\\\"Invalid Token or Authorization HTTP header\\\", http_code=HTTPStatus.UNAUTHORIZED)\\n else:\\n raise\\n except AuthException:\\n if self.config[\\\"global\\\"].get(\\\"test.user_not_authorized\\\"):\\n return {\\\"id\\\": \\\"fake-token-id-for-test\\\",\\n \\\"project_id\\\": self.config[\\\"global\\\"].get(\\\"test.project_not_authorized\\\", \\\"admin\\\"),\\n \\\"username\\\": self.config[\\\"global\\\"][\\\"test.user_not_authorized\\\"], \\\"admin\\\": True}\\n else:\\n raise\\n except Exception:\\n self.logger.exception(\\\"Error during token validation using internal backend\\\")\\n raise AuthException(\\\"Error during token validation using internal backend\\\",\\n http_code=HTTPStatus.UNAUTHORIZED)\",\n \"def _parse_token(self, body):\\n\\n token_match = re.search('var\\\\s*token\\\\s*=[\\\\s\\\\']*(\\\\d+)', body)\\n return int(token_match.group(1))\",\n \"def get_current_pub_key(token: str = Depends(token_header)):\\n return decode_token(token)\",\n \"def verify_auth_token(token):\\n serializer = Serializer(SECRET_KEY)\\n try:\\n data = serializer.loads(token)\\n except SignatureExpired:\\n return None # valid token, but expired\\n except BadSignature:\\n return None # invalid token\\n return data['token']\",\n \"def get_token(self):\\n\\n try:\\n return jwt.decode(self.fetch_token(), KEY, algorithms=['HS256'])\\n except jwt.exceptions.DecodeError:\\n raise InvalidToken\",\n \"def token(self) -> Token:\\n return getattr(self, \\\"tok\\\", None)\",\n \"def get_token_auth_header():\\n auth = request.headers.get(\\\"Authorization\\\", None)\\n print(auth)\\n\\n if not auth:\\n raise AuthError({\\\"code\\\": \\\"authorization_header_missing\\\",\\n \\\"description\\\":\\n \\\"Authorization header is expected\\\"}, 401)\\n \\n parts = auth.split()\\n \\n if parts[0].lower() != \\\"bearer\\\":\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\":\\n \\\"Authorization header must start with\\\"\\n \\\" Bearer\\\"}, 401)\\n elif len(parts) == 1:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\": \\\"Token not found\\\"}, 401)\\n elif len(parts) > 2:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\":\\n \\\"Authorization header must be\\\"\\n \\\" Bearer token\\\"}, 401)\\n\\n token = parts[1]\\n return token\",\n \"def get_token_auth_header():\\n auth = request.headers.get('Authorization', None)\\n if not auth:\\n raise AuthError({'code': 'authorization_header_missing',\\n 'description': 'Authorization header is expected'}, 401)\\n\\n parts = auth.split()\\n\\n if parts[0].lower() != 'bearer':\\n raise AuthError({'code': 'invalid_header',\\n 'description': 'Authorization header must start with Bearer'}, 401)\\n\\n if len(parts) < 2:\\n raise AuthError({'code': 'invalid_header',\\n 'description': 'Token not found after Bearer'}, 401)\\n\\n if len(parts) > 2:\\n raise AuthError({'code': 'invalid_header',\\n 'description': 'Authorization header is an invalid token structure'}, 401)\\n\\n return parts[1]\",\n \"def process_id_from(self):\\r\\n return self._tokens[1]\",\n \"def get_token_auth_header():\\n auth = request.headers.get('Authorization', None)\\n if not auth:\\n raise AuthError({\\n 'code': 'authorization_header_missing',\\n 'description': 'Authorization header is expected.'\\n }, 401)\\n\\n parts = auth.split()\\n if parts[0].lower() != 'bearer':\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must start with \\\"Bearer\\\".'\\n }, 401)\\n\\n elif len(parts) == 1:\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Token not found.'\\n }, 401)\\n\\n elif len(parts) > 2:\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must be bearer token.'\\n }, 401)\\n\\n token = parts[1]\\n return token\",\n \"def get_token(headers):\\n bearer = headers.get('Authorization')\\n if bearer:\\n try:\\n token_type, token = bearer.rsplit(' ', 1)\\n except ValueError:\\n raise TokenError('Wrong bearer string: %s', bearer)\\n\\n if token_type != 'Bearer':\\n raise TokenError('Wrong token type: %s, must be %s',\\n token_type, 'Bearer')\\n return token\\n raise TokenError('No token is given in the Authorization header')\",\n \"def _get_token(self): # pragma: no cover\\n\\n tokenCookie = None\\n for cookie in self._session.cookies:\\n if \\\"mast_token\\\" in cookie.name:\\n tokenCookie = cookie\\n break\\n\\n if not tokenCookie:\\n warnings.warn(\\\"No auth token found.\\\", AuthenticationWarning)\\n\\n return tokenCookie\",\n \"def parse_token(token):\\n return jwt.decode(token, app.config['JWT_SECRET'])\",\n \"async def get_user_token_strict(token: Optional[str] = Depends(get_user_token)) -> str:\\n if token:\\n return token\\n raise exceptions.AuthenticationException()\",\n \"def get_token():\\n # get authorization header:\\n auth = request.headers.get('Authorization', None)\\n \\n # authorization header should be included:\\n if auth is None:\\n raise JWTError(\\n {\\n 'code': 'authorization_header_missing',\\n 'description': 'Authorization header is expected.'\\n }, \\n 401\\n )\\n \\n # authorization header should be 'Bearer [JWT]'\\n parts = auth.split()\\n if parts[0].lower() != 'bearer':\\n raise JWTError(\\n {\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must start with \\\"Bearer\\\".'\\n }, \\n 401\\n )\\n elif len(parts) == 1:\\n raise JWTError(\\n {\\n 'code': 'invalid_header',\\n 'description': 'Token not found.'\\n }, \\n 401\\n )\\n elif len(parts) > 2:\\n raise JWTError(\\n {\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must be bearer token.'\\n }, \\n 401\\n )\\n\\n # extract JWT:\\n token = parts[1]\\n\\n return token\",\n \"def retrieve_token(filename):\\n with open(filename, 'r') as f:\\n token = f.readline()\\n\\n return token\",\n \"def getToken(request):\\n try:\\n token = request.META['HTTP_AUTHORIZATION'].split()[1]\\n except:\\n token = \\\"\\\"\\n return token\",\n \"def _get_token(self) -> str:\\n if IS_SUPERVISOR:\\n # On supervisor installs the token is provided by a environment variable\\n return os.environ[\\\"HASSIO_TOKEN\\\"]\\n return self._token\",\n \"def prep_token(**kwargs):\\n token = kwargs.get('token')\\n if not token:\\n token = oauth2_wrappers.gen_token()\\n return token\",\n \"def get_task_token(decision):\\n try:\\n return decision[\\\"taskToken\\\"]\\n except KeyError:\\n # No taskToken returned\\n return None\",\n \"def get_id(self, word, add=False):\\n if word not in self.word_to_id:\\n if add:\\n self._add_new_word(word)\\n return self.word_to_id[constants.UNK_TOKEN]\\n return self.word_to_id[word]\",\n \"def get_token(self): # pragma: no cover\\n\\t\\treturn (session.get(\\\"access_token\\\"), \\\"\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8310672","0.7980398","0.79235566","0.7840283","0.7578476","0.730748","0.71591955","0.7151534","0.7099397","0.6803577","0.66393685","0.65554255","0.6520694","0.64726806","0.64626735","0.6437027","0.6431865","0.6408412","0.63829017","0.6313626","0.62993306","0.6289849","0.62813705","0.62648714","0.62648714","0.62607694","0.62452286","0.62452286","0.62452286","0.6183551","0.61645305","0.6161283","0.6161283","0.6161283","0.6134753","0.6118412","0.6109119","0.6093843","0.60914665","0.6087006","0.60820216","0.60596764","0.60578436","0.6046646","0.60442126","0.60429186","0.60398537","0.60335237","0.6032102","0.60296017","0.60249937","0.6010589","0.599783","0.5995214","0.59918994","0.59489554","0.59388304","0.59348774","0.59307253","0.59307253","0.5927049","0.59014535","0.5879281","0.58682775","0.58655936","0.58544874","0.5845288","0.58435464","0.5841719","0.5834561","0.583097","0.5830678","0.58211905","0.581653","0.5815282","0.5775528","0.5761582","0.5761389","0.5749766","0.57477707","0.5739386","0.57343584","0.57139224","0.57043034","0.56944424","0.568379","0.5676884","0.56684685","0.5658094","0.5640935","0.56401306","0.5633947","0.5624952","0.56210846","0.5616927","0.56167054","0.5612738","0.560682","0.5597555","0.55860263"],"string":"[\n \"0.8310672\",\n \"0.7980398\",\n \"0.79235566\",\n \"0.7840283\",\n \"0.7578476\",\n \"0.730748\",\n \"0.71591955\",\n \"0.7151534\",\n \"0.7099397\",\n \"0.6803577\",\n \"0.66393685\",\n \"0.65554255\",\n \"0.6520694\",\n \"0.64726806\",\n \"0.64626735\",\n \"0.6437027\",\n \"0.6431865\",\n \"0.6408412\",\n \"0.63829017\",\n \"0.6313626\",\n \"0.62993306\",\n \"0.6289849\",\n \"0.62813705\",\n \"0.62648714\",\n \"0.62648714\",\n \"0.62607694\",\n \"0.62452286\",\n \"0.62452286\",\n \"0.62452286\",\n \"0.6183551\",\n \"0.61645305\",\n \"0.6161283\",\n \"0.6161283\",\n \"0.6161283\",\n \"0.6134753\",\n \"0.6118412\",\n \"0.6109119\",\n \"0.6093843\",\n \"0.60914665\",\n \"0.6087006\",\n \"0.60820216\",\n \"0.60596764\",\n \"0.60578436\",\n \"0.6046646\",\n \"0.60442126\",\n \"0.60429186\",\n \"0.60398537\",\n \"0.60335237\",\n \"0.6032102\",\n \"0.60296017\",\n \"0.60249937\",\n \"0.6010589\",\n \"0.599783\",\n \"0.5995214\",\n \"0.59918994\",\n \"0.59489554\",\n \"0.59388304\",\n \"0.59348774\",\n \"0.59307253\",\n \"0.59307253\",\n \"0.5927049\",\n \"0.59014535\",\n \"0.5879281\",\n \"0.58682775\",\n \"0.58655936\",\n \"0.58544874\",\n \"0.5845288\",\n \"0.58435464\",\n \"0.5841719\",\n \"0.5834561\",\n \"0.583097\",\n \"0.5830678\",\n \"0.58211905\",\n \"0.581653\",\n \"0.5815282\",\n \"0.5775528\",\n \"0.5761582\",\n \"0.5761389\",\n \"0.5749766\",\n \"0.57477707\",\n \"0.5739386\",\n \"0.57343584\",\n \"0.57139224\",\n \"0.57043034\",\n \"0.56944424\",\n \"0.568379\",\n \"0.5676884\",\n \"0.56684685\",\n \"0.5658094\",\n \"0.5640935\",\n \"0.56401306\",\n \"0.5633947\",\n \"0.5624952\",\n \"0.56210846\",\n \"0.5616927\",\n \"0.56167054\",\n \"0.5612738\",\n \"0.560682\",\n \"0.5597555\",\n \"0.55860263\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8298625"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":7388,"cells":{"query":{"kind":"string","value":"tokenid to token (string)."},"document":{"kind":"string","value":"def id_to_token(self, idx):\n return self._id2token[idx]"},"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 map_id_to_token(self, id: int):\n return self._id_to_token[id]","def token_to_id(self, token):\r\n return self.encoder.get(token, self.encoder.get(self.unk_token))","def token_to_id(self, token):\n token = self.process_token(token)\n return self.token2id.get(token, len(self.token2id) - 1)","def _convert_id_to_token(self, index):\n if index in self.fairseq_ids_to_tokens:\n return self.fairseq_ids_to_tokens[index]\n return self.sp_model.IdToPiece(index - self.fairseq_offset)","def token_to_id(self, token):\n token = self.process_token(token)\n return self._token2id.get(token, len(self._token2id) - 1)","def _convert_token_to_id(self, token):\n return self.sp_model.PieceToId(str(token))","def id_to_token(self, index):\r\n return self.decoder.get(index)","def _convert_id_to_token(self, index, return_unicode=True):\n token = self.sp_model.IdToPiece(index)\n return token","def token(self) -> str:","def _convert_id_to_token(self, index):\n return self.reverse_vocab.get(index, self.unk_token)","def _convert_id_to_token(self, index, return_unicode=True):\n token = self.sp_model.IdToPiece(index)\n if six.PY2 and return_unicode and isinstance(token, str):\n token = token.decode('utf-8')\n return token","def token_id_hex(self) -> str: # this is *ALSO* a MINT property\n return self.token_id.hex()","def _convert_token_to_id(self, token):\n return self.sp_model.PieceToId(token)","def get_token(self, token_id):\n raise exception.NotImplemented() # pragma: no cover","def process_id_to(self):\r\n return self._tokens[3]","def generate_token_string(token):\n if JWT_AUTH:\n return 'JWT {}'.format(token)\n else:\n return 'Token {}'.format(token)","def token_id(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"token_id\")","def _convert_token_to_id(self, token):\n return self.vocab.get(token, self.vocab.get(self.unk_token))","def token2String(self,tokens):\n return self._support.token2String(tokens)","def make_token(self, data: object) -> str:\n return self.serializer.dumps(data)","def get_token_id(self):\n return f\"{self.document_title}_{self.index}\"","def token(self, id):\r\n return Token(self, id)","def make_token():\n return secrets.token_urlsafe(36)","def map_token_to_id(self, token: str):\n if token not in self._token_to_id:\n token = self._unk_token\n return self._token_to_id[token]","def token(db):\n user = User.find_by_identity('admin@localhost.com')\n return user.serialize_token()","def tostr(token):\n if token is True:\n return '#t'\n if token is False:\n return '#f'\n if isa(token, Symbol):\n return token\n if isa(token, str):\n import json\n return json.dumps(token)\n if isa(token, complex):\n result = str(token).replace('j', 'i')\n if result.find('(') < 0:\n return result\n return result[1:-1]\n if isa(token, list):\n return '(' + ' '.join(map(tostr, token)) + ')'\n return str(token)","def _convert_token_to_id(self, token):\n if token in self.fairseq_tokens_to_ids:\n return self.fairseq_tokens_to_ids[token]\n spm_id = self.sp_model.PieceToId(token)\n\n # Need to return unknown token if the SP model returned 0\n return spm_id + self.fairseq_offset if spm_id else self.unk_token_id","def odb_token():\n return genToken()","def token(self) -> str:\n return pulumi.get(self, \"token\")","def token(self) -> str:\n return pulumi.get(self, \"token\")","def token(self) -> str:\n return pulumi.get(self, \"token\")","def generateToken():\n length = random.randint(8, 32)\n rdmtoken = ''.join(random.choice(string.printable) for i in range(length))\n return f'{rdmtoken}'","def decode_token(token):\n text = xlmr.decode(torch.tensor(token).long())\n return text.replace(' ', '')","def generate_token(self):\n token = randint(100000000000000000, 999999999999999999)\n return str(token)","def token(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"token\")","def convert_to_string(tokens):\n\n return ' '.join(tokens)","def __str__(self):\n return str(self.__token)","def token(self) -> str:\n raise NotImplementedError","def encode_auth_token(self, id):\n payload = {\n \"exp\": datetime.utcnow()\n + timedelta(\n days=current_app.config.get(\"TOKEN_EXPIRATION_DAYS\"),\n seconds=current_app.config.get(\"TOKEN_EXPIRATION_SECONDS\"),\n ),\n \"iat\": datetime.utcnow(),\n \"sub\": id,\n }\n return jwt.encode(\n payload, current_app.config.get(\"SECRET_KEY\"), algorithm=\"HS256\"\n )","def generate_token():\n return uuid4()","def new_token(*args, **kwargs):\n return uuid.uuid4().hex","def token_str(self) -> Optional[str]:\n return self._token_str","def _id(self):\n result = ''\n while self.current_char is not None and self.current_char.isalnum() or self.current_char == '_':\n result += self.current_char\n self.advance()\n\n return Token(ID, result)","def get_client_token(**_):\n return str(uuid.uuid4())","def get_token(self, tid):\n if self.lliagraph:\n return self.lliagraph.get_token(tid)\n else:\n return None","def string2Token(self,phrase):\n return self._support.string2Token(phrase)","def identifier(self) -> str:\n return self.current_token","def create_token(self,uid):\n token_str = self.get_random(5) + str(uid) + str(int(time.time()))\n m = hashlib.md5()\n m.update(token_str)\n return m.hexdigest()","def process_id_from(self):\r\n return self._tokens[1]","def generate_token(self, user_id):\n try:\n # set up a payload with an expiration time\n payload = {\n 'exp': datetime.utcnow() + timedelta(minutes=10),\n 'iat': datetime.utcnow(),\n 'sub': user_id\n }\n # create the byte string encoded token using payload and SECRET key\n jwt_string = jwt.encode(\n payload,\n SECRET_KEY,\n algorithm='HS256'\n )\n return jwt_string\n except Exception as e:\n # return an error in string format if an exception occurs\n return str(e)","def __str__(self):\n return self.token","def token(uncapped_token):\n return uncapped_token","def token(self):\n \n payload = {\n 'sub_type': self.sub_type,\n '_hash' : self._hash,\n 'jti' : str(uuid.uuid4())\n }\n return jwt.encode(payload, self.secret, self.algo).decode('utf-8')","def get(uid: int, token_id: int):\n\n token = Token.get(uid, token_id).as_dto().to_primitive()\n\n if token:\n return token.to_primitive()\n else:\n raise NotFound(\"Token Not Found\")","def token(uncapped_token: Contract):\n return uncapped_token","def string_val(self) -> str:\n return self.current_token","def decode_tokens_to_str(self, tokens: List[int]) -> str:\n hypothesis = self.tokenizer.ids_to_text(tokens)\n return hypothesis","def get_token(id=None, name=None):\n\tif id is None and name is None:\n\t\tname = config['username']\n\treturn get_user(id=id, name=name, get_missing=False).token","def identifier(self):\n _id = ''\n while self.current_char is not None and self.current_char.isalpha():\n # inner loop to get alphanumeric characters\n while self.current_char is not None and\\\n self.current_char.isalnum():\n _id += self.current_char\n self.advance()\n return Token(self.tokentype['ID'], _id)","def getUniStr(self):\n return(\"%s/%s\"%(self.token.id,self.type))","def get_token(self):\n return self.__token","def get_token(self):\n return self.__token","def _identifier(self):\n identifier = self._get_next_symbol()\n\n while True:\n symbol = self._get_next_symbol()\n if symbol != None and symbol.isalnum():\n identifier += symbol\n else:\n if symbol != None:\n self._back()\n break\n\n return self._create_identifier_token(identifier)","def id(self, tokens):\n if len(tokens) != 1:\n raise Exception(\"Unexpected argument counts\")\n return tokens[0].value","def decode_token(token):\n payload = None\n try:\n payload = jwt.decode(token.encode('utf-8'), '1$Arh\"1bWa/7+OS', algorithm='HS256')['u_id']\n except jwt.InvalidTokenError:\n pass\n return payload","def token(self):\n return self[\"token\"]","def token2id(data, mode):\n vocab_path = 'vocab.' + mode\n in_path = data + '.' + mode\n out_path = data + '_ids.' + mode\n _, vocab = load_vocab(os.path.join(config.PROCESSED_PATH, vocab_path))\n in_file = open(os.path.join(config.PROCESSED_PATH, in_path), 'rb')\n out_file = open(os.path.join(config.PROCESSED_PATH, out_path), 'wb')\n\n lines = in_file.read().splitlines()\n for line in lines:\n if mode == 'dec': # we only care about '<s>' and </s> in encoder\n ids = [vocab[b'<s>']]\n else:\n ids = []\n ids.extend(sentence2id(vocab, line))\n # ids.extend([vocab.get(token, vocab['<unk>']) for token in basic_tokenizer(line)])\n if mode == 'dec':\n ids.append(vocab[b'</s>'])\n out_file.write(b' '.join(str(id_).encode('ascii') for id_ in ids) + b'\\n')","def generate_token(payload: Any, secret: str | List[str]) -> str:\n return url_encode_full_stops(URLSafeTimedSerializer(secret).dumps(payload, \"token\"))","def encode_token(userId):\n token = jwt.encode({'userId': userId, 'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=20)},\n secret_key).decode('utf-8')\n return token","def token_id(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"token_id\")","def generate_client_token_by_uuid():\n return str(uuid.uuid4())","def generate_client_token_by_uuid():\n return str(uuid.uuid4())","def token(self, ent):\n if ent.eid in self.lookup: return self.lookup[ent.eid]\n\n if ent.tid == data.AGENT_TYPE_ID: prefix = 'A'\n elif ent.tid in data.combatants: prefix = 'C'\n elif ent.tid in data.gatherable: prefix = 'G'\n\n ct = self.counts[prefix]\n self.counts[prefix] += 1\n tok = \"{}{}\".format(prefix, ct)\n self.lookup[ent.eid] = tok\n return tok","def token(self):\n if not hasattr(self,'_tokens'):\n ts = str(time.time())\n rs = str(random.randint(1234,65535))\n self._tokens = '%s_%s_%s' % (self.key().name(),ts,rs)\n return self._tokens","def _generate_token_value():\n return secrets.token_urlsafe()","def token(self, ent):\n if ent.eid in self.lookup: return self.lookup[ent.eid]\n\n if ent.tid == data.AGENT_TYPE_ID: prefix = 'A'\n elif ent.tid in data.combatants: prefix = 'C'\n elif ent.tid in data.gatherable: prefix = 'G'\n\n self.lookup[ent.eid] = prefix\n return prefix","def get_token(self, bot_id):\n res = self.execute(TABELLE['bot']['select']['by_id'], (bot_id,))\n # print(res)\n return res","def token_to_word(self, token):\n\n word = \" \" if token == 0 else self.index_to_word[token]\n return word","def parse_token(bn,token):\n return bn.split(token)[1].split('_')[0]","def convertTokensToSourceString(self, tokens):\n sense = self.sense\n return \" \".join([sense.tokens[t-1][1]\n if t > 0 else \"[%s]\" % sense.tokens[sense.mapNodeToMainToken[-t]-1][0]\n for t in tokens])","def toString(self):\n return self.tokens.toString()","def token(self):\r\n return self._token","def token(self):\n payload = {\n 'id': str(self.id),\n 'username': self.username,\n \"exp\": datetime.now() + timedelta(days=2)\n }\n return jwt.encode(payload, SECRET_KEY).decode('utf-8')","def token_id_to(self, token_id_to):\n\n self._token_id_to = token_id_to","def get_token(self):\n\n return self._token","def generate(self):\n return self.rpc.call(MsfRpcMethod.AuthTokenGenerate)['token']","def token(db):\n token = TokenFactory()\n db.session.commit()\n return token","def token(self):\n return self._token","def token(self):\n return self._token","def token(self):\n return self._token","def _token_to_id(self, sequence_tokens, token_map, char_map, ngram=0,\n token_ngram_map=None, max_char_sequence_length=-1,\n max_char_length_per_token=-1):\n token_id_list = []\n char_id_list = []\n char_in_token_id_list = []\n ngram_id_list = []\n for token in sequence_tokens:\n char_id = [char_map.get(x, self.VOCAB_UNKNOWN) for x in token]\n char_id_list.extend(char_id[0:max_char_sequence_length])\n char_in_token = [char_map.get(x, self.VOCAB_UNKNOWN)\n for x in token[0:max_char_length_per_token]]\n char_in_token_id_list.append(char_in_token)\n\n token_id_list.append(\n token_map.get(token, token_map[self.VOCAB_UNKNOWN]))\n if ngram > 1:\n for j in range(2, ngram + 1):\n ngram_id_list.extend(\n token_ngram_map[x] for x in\n [\"\".join(sequence_tokens[k:k + j]) for k in\n range(len(sequence_tokens) - j + 1)] if x in\n token_ngram_map)\n if not sequence_tokens:\n token_id_list.append(self.VOCAB_PADDING)\n char_id_list.append(self.VOCAB_PADDING)\n char_in_token_id_list.append([self.VOCAB_PADDING])\n if not ngram_id_list:\n ngram_id_list.append(token_ngram_map[self.VOCAB_PADDING])\n return token_id_list, char_id_list, char_in_token_id_list, ngram_id_list","def get_token(self):\n token = self._session.token\n return token","def get_word(self, word_id):\n if word_id in self.id_to_word:\n return self.id_to_word[word_id]\n return constants.UNK_TOKEN","def generate_new_token(uid):\n random_token = uuid.uuid4()\n token = TokenAuth(user_id=uid, token=random_token)\n token.save()\n return random_token","def tokenize(*args, **kwargs):\n if kwargs.pop('pure', False):\n return base.tokenize(*args)\n else:\n return str(uuid.uuid4())","def decode_token(token):\n try:\n # Decode token with our secret key\n payload = jwt.decode(token, SECRET_KEY)\n return payload['sub']\n except jwt.ExpiredSignatureError:\n # token has expired\n return \"Timed out. Please login to get a new token\"\n except jwt.InvalidTokenError:\n return \"Invalid token. Please register or login\"","def token(self) -> Optional[str]:\n return self._builder._token","def convert_tokens_to_string(self, tokens):\r\n text = ''.join(tokens)\r\n text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors=self.errors)\r\n return text","def decode_token(token):\n try:\n # try to decode the token using our SECRET variable\n payload = jwt.decode(token, app.config.get('SECRET_KEY'), algorithms=['HS256'])\n return payload['sub']\n except jwt.ExpiredSignatureError:\n # the token is expired, return an error string\n return \"Expired token. Please login to get a new token\"\n except jwt.InvalidTokenError:\n # the token is invalid, return an error string\n return \"Invalid token. Please register or login\""],"string":"[\n \"def map_id_to_token(self, id: int):\\n return self._id_to_token[id]\",\n \"def token_to_id(self, token):\\r\\n return self.encoder.get(token, self.encoder.get(self.unk_token))\",\n \"def token_to_id(self, token):\\n token = self.process_token(token)\\n return self.token2id.get(token, len(self.token2id) - 1)\",\n \"def _convert_id_to_token(self, index):\\n if index in self.fairseq_ids_to_tokens:\\n return self.fairseq_ids_to_tokens[index]\\n return self.sp_model.IdToPiece(index - self.fairseq_offset)\",\n \"def token_to_id(self, token):\\n token = self.process_token(token)\\n return self._token2id.get(token, len(self._token2id) - 1)\",\n \"def _convert_token_to_id(self, token):\\n return self.sp_model.PieceToId(str(token))\",\n \"def id_to_token(self, index):\\r\\n return self.decoder.get(index)\",\n \"def _convert_id_to_token(self, index, return_unicode=True):\\n token = self.sp_model.IdToPiece(index)\\n return token\",\n \"def token(self) -> str:\",\n \"def _convert_id_to_token(self, index):\\n return self.reverse_vocab.get(index, self.unk_token)\",\n \"def _convert_id_to_token(self, index, return_unicode=True):\\n token = self.sp_model.IdToPiece(index)\\n if six.PY2 and return_unicode and isinstance(token, str):\\n token = token.decode('utf-8')\\n return token\",\n \"def token_id_hex(self) -> str: # this is *ALSO* a MINT property\\n return self.token_id.hex()\",\n \"def _convert_token_to_id(self, token):\\n return self.sp_model.PieceToId(token)\",\n \"def get_token(self, token_id):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"def process_id_to(self):\\r\\n return self._tokens[3]\",\n \"def generate_token_string(token):\\n if JWT_AUTH:\\n return 'JWT {}'.format(token)\\n else:\\n return 'Token {}'.format(token)\",\n \"def token_id(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"token_id\\\")\",\n \"def _convert_token_to_id(self, token):\\n return self.vocab.get(token, self.vocab.get(self.unk_token))\",\n \"def token2String(self,tokens):\\n return self._support.token2String(tokens)\",\n \"def make_token(self, data: object) -> str:\\n return self.serializer.dumps(data)\",\n \"def get_token_id(self):\\n return f\\\"{self.document_title}_{self.index}\\\"\",\n \"def token(self, id):\\r\\n return Token(self, id)\",\n \"def make_token():\\n return secrets.token_urlsafe(36)\",\n \"def map_token_to_id(self, token: str):\\n if token not in self._token_to_id:\\n token = self._unk_token\\n return self._token_to_id[token]\",\n \"def token(db):\\n user = User.find_by_identity('admin@localhost.com')\\n return user.serialize_token()\",\n \"def tostr(token):\\n if token is True:\\n return '#t'\\n if token is False:\\n return '#f'\\n if isa(token, Symbol):\\n return token\\n if isa(token, str):\\n import json\\n return json.dumps(token)\\n if isa(token, complex):\\n result = str(token).replace('j', 'i')\\n if result.find('(') < 0:\\n return result\\n return result[1:-1]\\n if isa(token, list):\\n return '(' + ' '.join(map(tostr, token)) + ')'\\n return str(token)\",\n \"def _convert_token_to_id(self, token):\\n if token in self.fairseq_tokens_to_ids:\\n return self.fairseq_tokens_to_ids[token]\\n spm_id = self.sp_model.PieceToId(token)\\n\\n # Need to return unknown token if the SP model returned 0\\n return spm_id + self.fairseq_offset if spm_id else self.unk_token_id\",\n \"def odb_token():\\n return genToken()\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def generateToken():\\n length = random.randint(8, 32)\\n rdmtoken = ''.join(random.choice(string.printable) for i in range(length))\\n return f'{rdmtoken}'\",\n \"def decode_token(token):\\n text = xlmr.decode(torch.tensor(token).long())\\n return text.replace(' ', '')\",\n \"def generate_token(self):\\n token = randint(100000000000000000, 999999999999999999)\\n return str(token)\",\n \"def token(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def convert_to_string(tokens):\\n\\n return ' '.join(tokens)\",\n \"def __str__(self):\\n return str(self.__token)\",\n \"def token(self) -> str:\\n raise NotImplementedError\",\n \"def encode_auth_token(self, id):\\n payload = {\\n \\\"exp\\\": datetime.utcnow()\\n + timedelta(\\n days=current_app.config.get(\\\"TOKEN_EXPIRATION_DAYS\\\"),\\n seconds=current_app.config.get(\\\"TOKEN_EXPIRATION_SECONDS\\\"),\\n ),\\n \\\"iat\\\": datetime.utcnow(),\\n \\\"sub\\\": id,\\n }\\n return jwt.encode(\\n payload, current_app.config.get(\\\"SECRET_KEY\\\"), algorithm=\\\"HS256\\\"\\n )\",\n \"def generate_token():\\n return uuid4()\",\n \"def new_token(*args, **kwargs):\\n return uuid.uuid4().hex\",\n \"def token_str(self) -> Optional[str]:\\n return self._token_str\",\n \"def _id(self):\\n result = ''\\n while self.current_char is not None and self.current_char.isalnum() or self.current_char == '_':\\n result += self.current_char\\n self.advance()\\n\\n return Token(ID, result)\",\n \"def get_client_token(**_):\\n return str(uuid.uuid4())\",\n \"def get_token(self, tid):\\n if self.lliagraph:\\n return self.lliagraph.get_token(tid)\\n else:\\n return None\",\n \"def string2Token(self,phrase):\\n return self._support.string2Token(phrase)\",\n \"def identifier(self) -> str:\\n return self.current_token\",\n \"def create_token(self,uid):\\n token_str = self.get_random(5) + str(uid) + str(int(time.time()))\\n m = hashlib.md5()\\n m.update(token_str)\\n return m.hexdigest()\",\n \"def process_id_from(self):\\r\\n return self._tokens[1]\",\n \"def generate_token(self, user_id):\\n try:\\n # set up a payload with an expiration time\\n payload = {\\n 'exp': datetime.utcnow() + timedelta(minutes=10),\\n 'iat': datetime.utcnow(),\\n 'sub': user_id\\n }\\n # create the byte string encoded token using payload and SECRET key\\n jwt_string = jwt.encode(\\n payload,\\n SECRET_KEY,\\n algorithm='HS256'\\n )\\n return jwt_string\\n except Exception as e:\\n # return an error in string format if an exception occurs\\n return str(e)\",\n \"def __str__(self):\\n return self.token\",\n \"def token(uncapped_token):\\n return uncapped_token\",\n \"def token(self):\\n \\n payload = {\\n 'sub_type': self.sub_type,\\n '_hash' : self._hash,\\n 'jti' : str(uuid.uuid4())\\n }\\n return jwt.encode(payload, self.secret, self.algo).decode('utf-8')\",\n \"def get(uid: int, token_id: int):\\n\\n token = Token.get(uid, token_id).as_dto().to_primitive()\\n\\n if token:\\n return token.to_primitive()\\n else:\\n raise NotFound(\\\"Token Not Found\\\")\",\n \"def token(uncapped_token: Contract):\\n return uncapped_token\",\n \"def string_val(self) -> str:\\n return self.current_token\",\n \"def decode_tokens_to_str(self, tokens: List[int]) -> str:\\n hypothesis = self.tokenizer.ids_to_text(tokens)\\n return hypothesis\",\n \"def get_token(id=None, name=None):\\n\\tif id is None and name is None:\\n\\t\\tname = config['username']\\n\\treturn get_user(id=id, name=name, get_missing=False).token\",\n \"def identifier(self):\\n _id = ''\\n while self.current_char is not None and self.current_char.isalpha():\\n # inner loop to get alphanumeric characters\\n while self.current_char is not None and\\\\\\n self.current_char.isalnum():\\n _id += self.current_char\\n self.advance()\\n return Token(self.tokentype['ID'], _id)\",\n \"def getUniStr(self):\\n return(\\\"%s/%s\\\"%(self.token.id,self.type))\",\n \"def get_token(self):\\n return self.__token\",\n \"def get_token(self):\\n return self.__token\",\n \"def _identifier(self):\\n identifier = self._get_next_symbol()\\n\\n while True:\\n symbol = self._get_next_symbol()\\n if symbol != None and symbol.isalnum():\\n identifier += symbol\\n else:\\n if symbol != None:\\n self._back()\\n break\\n\\n return self._create_identifier_token(identifier)\",\n \"def id(self, tokens):\\n if len(tokens) != 1:\\n raise Exception(\\\"Unexpected argument counts\\\")\\n return tokens[0].value\",\n \"def decode_token(token):\\n payload = None\\n try:\\n payload = jwt.decode(token.encode('utf-8'), '1$Arh\\\"1bWa/7+OS', algorithm='HS256')['u_id']\\n except jwt.InvalidTokenError:\\n pass\\n return payload\",\n \"def token(self):\\n return self[\\\"token\\\"]\",\n \"def token2id(data, mode):\\n vocab_path = 'vocab.' + mode\\n in_path = data + '.' + mode\\n out_path = data + '_ids.' + mode\\n _, vocab = load_vocab(os.path.join(config.PROCESSED_PATH, vocab_path))\\n in_file = open(os.path.join(config.PROCESSED_PATH, in_path), 'rb')\\n out_file = open(os.path.join(config.PROCESSED_PATH, out_path), 'wb')\\n\\n lines = in_file.read().splitlines()\\n for line in lines:\\n if mode == 'dec': # we only care about '<s>' and </s> in encoder\\n ids = [vocab[b'<s>']]\\n else:\\n ids = []\\n ids.extend(sentence2id(vocab, line))\\n # ids.extend([vocab.get(token, vocab['<unk>']) for token in basic_tokenizer(line)])\\n if mode == 'dec':\\n ids.append(vocab[b'</s>'])\\n out_file.write(b' '.join(str(id_).encode('ascii') for id_ in ids) + b'\\\\n')\",\n \"def generate_token(payload: Any, secret: str | List[str]) -> str:\\n return url_encode_full_stops(URLSafeTimedSerializer(secret).dumps(payload, \\\"token\\\"))\",\n \"def encode_token(userId):\\n token = jwt.encode({'userId': userId, 'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=20)},\\n secret_key).decode('utf-8')\\n return token\",\n \"def token_id(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"token_id\\\")\",\n \"def generate_client_token_by_uuid():\\n return str(uuid.uuid4())\",\n \"def generate_client_token_by_uuid():\\n return str(uuid.uuid4())\",\n \"def token(self, ent):\\n if ent.eid in self.lookup: return self.lookup[ent.eid]\\n\\n if ent.tid == data.AGENT_TYPE_ID: prefix = 'A'\\n elif ent.tid in data.combatants: prefix = 'C'\\n elif ent.tid in data.gatherable: prefix = 'G'\\n\\n ct = self.counts[prefix]\\n self.counts[prefix] += 1\\n tok = \\\"{}{}\\\".format(prefix, ct)\\n self.lookup[ent.eid] = tok\\n return tok\",\n \"def token(self):\\n if not hasattr(self,'_tokens'):\\n ts = str(time.time())\\n rs = str(random.randint(1234,65535))\\n self._tokens = '%s_%s_%s' % (self.key().name(),ts,rs)\\n return self._tokens\",\n \"def _generate_token_value():\\n return secrets.token_urlsafe()\",\n \"def token(self, ent):\\n if ent.eid in self.lookup: return self.lookup[ent.eid]\\n\\n if ent.tid == data.AGENT_TYPE_ID: prefix = 'A'\\n elif ent.tid in data.combatants: prefix = 'C'\\n elif ent.tid in data.gatherable: prefix = 'G'\\n\\n self.lookup[ent.eid] = prefix\\n return prefix\",\n \"def get_token(self, bot_id):\\n res = self.execute(TABELLE['bot']['select']['by_id'], (bot_id,))\\n # print(res)\\n return res\",\n \"def token_to_word(self, token):\\n\\n word = \\\" \\\" if token == 0 else self.index_to_word[token]\\n return word\",\n \"def parse_token(bn,token):\\n return bn.split(token)[1].split('_')[0]\",\n \"def convertTokensToSourceString(self, tokens):\\n sense = self.sense\\n return \\\" \\\".join([sense.tokens[t-1][1]\\n if t > 0 else \\\"[%s]\\\" % sense.tokens[sense.mapNodeToMainToken[-t]-1][0]\\n for t in tokens])\",\n \"def toString(self):\\n return self.tokens.toString()\",\n \"def token(self):\\r\\n return self._token\",\n \"def token(self):\\n payload = {\\n 'id': str(self.id),\\n 'username': self.username,\\n \\\"exp\\\": datetime.now() + timedelta(days=2)\\n }\\n return jwt.encode(payload, SECRET_KEY).decode('utf-8')\",\n \"def token_id_to(self, token_id_to):\\n\\n self._token_id_to = token_id_to\",\n \"def get_token(self):\\n\\n return self._token\",\n \"def generate(self):\\n return self.rpc.call(MsfRpcMethod.AuthTokenGenerate)['token']\",\n \"def token(db):\\n token = TokenFactory()\\n db.session.commit()\\n return token\",\n \"def token(self):\\n return self._token\",\n \"def token(self):\\n return self._token\",\n \"def token(self):\\n return self._token\",\n \"def _token_to_id(self, sequence_tokens, token_map, char_map, ngram=0,\\n token_ngram_map=None, max_char_sequence_length=-1,\\n max_char_length_per_token=-1):\\n token_id_list = []\\n char_id_list = []\\n char_in_token_id_list = []\\n ngram_id_list = []\\n for token in sequence_tokens:\\n char_id = [char_map.get(x, self.VOCAB_UNKNOWN) for x in token]\\n char_id_list.extend(char_id[0:max_char_sequence_length])\\n char_in_token = [char_map.get(x, self.VOCAB_UNKNOWN)\\n for x in token[0:max_char_length_per_token]]\\n char_in_token_id_list.append(char_in_token)\\n\\n token_id_list.append(\\n token_map.get(token, token_map[self.VOCAB_UNKNOWN]))\\n if ngram > 1:\\n for j in range(2, ngram + 1):\\n ngram_id_list.extend(\\n token_ngram_map[x] for x in\\n [\\\"\\\".join(sequence_tokens[k:k + j]) for k in\\n range(len(sequence_tokens) - j + 1)] if x in\\n token_ngram_map)\\n if not sequence_tokens:\\n token_id_list.append(self.VOCAB_PADDING)\\n char_id_list.append(self.VOCAB_PADDING)\\n char_in_token_id_list.append([self.VOCAB_PADDING])\\n if not ngram_id_list:\\n ngram_id_list.append(token_ngram_map[self.VOCAB_PADDING])\\n return token_id_list, char_id_list, char_in_token_id_list, ngram_id_list\",\n \"def get_token(self):\\n token = self._session.token\\n return token\",\n \"def get_word(self, word_id):\\n if word_id in self.id_to_word:\\n return self.id_to_word[word_id]\\n return constants.UNK_TOKEN\",\n \"def generate_new_token(uid):\\n random_token = uuid.uuid4()\\n token = TokenAuth(user_id=uid, token=random_token)\\n token.save()\\n return random_token\",\n \"def tokenize(*args, **kwargs):\\n if kwargs.pop('pure', False):\\n return base.tokenize(*args)\\n else:\\n return str(uuid.uuid4())\",\n \"def decode_token(token):\\n try:\\n # Decode token with our secret key\\n payload = jwt.decode(token, SECRET_KEY)\\n return payload['sub']\\n except jwt.ExpiredSignatureError:\\n # token has expired\\n return \\\"Timed out. Please login to get a new token\\\"\\n except jwt.InvalidTokenError:\\n return \\\"Invalid token. Please register or login\\\"\",\n \"def token(self) -> Optional[str]:\\n return self._builder._token\",\n \"def convert_tokens_to_string(self, tokens):\\r\\n text = ''.join(tokens)\\r\\n text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors=self.errors)\\r\\n return text\",\n \"def decode_token(token):\\n try:\\n # try to decode the token using our SECRET variable\\n payload = jwt.decode(token, app.config.get('SECRET_KEY'), algorithms=['HS256'])\\n return payload['sub']\\n except jwt.ExpiredSignatureError:\\n # the token is expired, return an error string\\n return \\\"Expired token. Please login to get a new token\\\"\\n except jwt.InvalidTokenError:\\n # the token is invalid, return an error string\\n return \\\"Invalid token. Please register or login\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7235237","0.69436103","0.6893987","0.6749872","0.67123127","0.6693682","0.6675571","0.6672998","0.6606152","0.66021","0.65837336","0.6532288","0.6484542","0.64636326","0.6327243","0.62979484","0.6255819","0.6240919","0.6239636","0.6181812","0.6127101","0.61171526","0.60637593","0.6061362","0.6053765","0.60517514","0.6048818","0.6044519","0.6042805","0.6042805","0.6042805","0.60329777","0.5997915","0.59543717","0.59190714","0.5912813","0.58965236","0.5892763","0.5883206","0.5861231","0.58474785","0.5845007","0.5838376","0.58327585","0.5821224","0.5816067","0.5812652","0.58045083","0.57851505","0.5771515","0.57606","0.57363135","0.57292736","0.57220364","0.57161117","0.57045275","0.56796557","0.5668658","0.5656479","0.56491184","0.5647739","0.5647739","0.5642004","0.562873","0.5625179","0.5623233","0.5620486","0.5614562","0.56116515","0.56103754","0.55896914","0.55896914","0.55888283","0.55881333","0.5576327","0.5576221","0.55753624","0.554752","0.55412453","0.55298054","0.552699","0.55260754","0.55240077","0.55210984","0.55091023","0.5505463","0.54969895","0.54915464","0.54915464","0.54915464","0.5480269","0.54339933","0.54221207","0.5411542","0.54101264","0.5406955","0.5399852","0.53924626","0.5385505"],"string":"[\n \"0.7235237\",\n \"0.69436103\",\n \"0.6893987\",\n \"0.6749872\",\n \"0.67123127\",\n \"0.6693682\",\n \"0.6675571\",\n \"0.6672998\",\n \"0.6606152\",\n \"0.66021\",\n \"0.65837336\",\n \"0.6532288\",\n \"0.6484542\",\n \"0.64636326\",\n \"0.6327243\",\n \"0.62979484\",\n \"0.6255819\",\n \"0.6240919\",\n \"0.6239636\",\n \"0.6181812\",\n \"0.6127101\",\n \"0.61171526\",\n \"0.60637593\",\n \"0.6061362\",\n \"0.6053765\",\n \"0.60517514\",\n \"0.6048818\",\n \"0.6044519\",\n \"0.6042805\",\n \"0.6042805\",\n \"0.6042805\",\n \"0.60329777\",\n \"0.5997915\",\n \"0.59543717\",\n \"0.59190714\",\n \"0.5912813\",\n \"0.58965236\",\n \"0.5892763\",\n \"0.5883206\",\n \"0.5861231\",\n \"0.58474785\",\n \"0.5845007\",\n \"0.5838376\",\n \"0.58327585\",\n \"0.5821224\",\n \"0.5816067\",\n \"0.5812652\",\n \"0.58045083\",\n \"0.57851505\",\n \"0.5771515\",\n \"0.57606\",\n \"0.57363135\",\n \"0.57292736\",\n \"0.57220364\",\n \"0.57161117\",\n \"0.57045275\",\n \"0.56796557\",\n \"0.5668658\",\n \"0.5656479\",\n \"0.56491184\",\n \"0.5647739\",\n \"0.5647739\",\n \"0.5642004\",\n \"0.562873\",\n \"0.5625179\",\n \"0.5623233\",\n \"0.5620486\",\n \"0.5614562\",\n \"0.56116515\",\n \"0.56103754\",\n \"0.55896914\",\n \"0.55896914\",\n \"0.55888283\",\n \"0.55881333\",\n \"0.5576327\",\n \"0.5576221\",\n \"0.55753624\",\n \"0.554752\",\n \"0.55412453\",\n \"0.55298054\",\n \"0.552699\",\n \"0.55260754\",\n \"0.55240077\",\n \"0.55210984\",\n \"0.55091023\",\n \"0.5505463\",\n \"0.54969895\",\n \"0.54915464\",\n \"0.54915464\",\n \"0.54915464\",\n \"0.5480269\",\n \"0.54339933\",\n \"0.54221207\",\n \"0.5411542\",\n \"0.54101264\",\n \"0.5406955\",\n \"0.5399852\",\n \"0.53924626\",\n \"0.5385505\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7267592"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":7389,"cells":{"query":{"kind":"string","value":"Return the vocabulary as a reversed dict object."},"document":{"kind":"string","value":"def reverse_vocab(self):\n return self._id2token"},"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 reverse_vocab(vocab: Dict[str, int]) -> Dict[int, str]:\n return {v: k for k, v in vocab.items()}","def reverse_dicts(self):\n\t\tself.rev_worddict = {self.worddict[word]: word for word in self.worddict}\n\t\tself.rev_classdict = {self.classdict[cl]: cl for cl in self.classdict}","def __reversed__(self):\n\t\treturn reversed(self.__dict__.values())","def reverse(dictionary):\n return {b: a for a, b in dictionary.items()}","def generate_vocab_dict(vocab):\n v_dict = {}\n for word in vocab:\n if len(word) in v_dict:\n v_dict[len(word)].append(word)\n else:\n v_dict[len(word)] = [word]\n return v_dict","def _rev_dict(d):\n return {v: k for k, v in d.items()}","def reverse_word_index(word_index):\n return dict([(word_index[word], word) for word in word_index])","def vocabulary(self):\n return self._vocabulary","def as_dict(self):\r\n return {self.words[i]: self.vectors[i] for i in range(self.n)}","def build_reverse_dictionary(word_to_id):\n reverse_dictionary = dict(zip(word_to_id.values(), word_to_id.keys()))\n return reverse_dictionary","def vocabulary(self):\n return [recid for recid in self._model.vocab]","def _get_term_dictionaries(self):\n\t\tforward_dict = {}\n\t\treverse_dict = defaultdict(list)\n\t\tfor term in self.terms():\n\t\t\tif (term.name is not None) and (\"obsolete\" not in term.name): \n\t\t\t\twords = [term.name]\n\t\t\t\twords.extend([x.description for x in list(term.synonyms)])\t# Add all the synonyms\n\t\t\t\twords = [re.sub(r\" ?\\([^)]+\\)\", \"\", x) for x in words]\t\t# Replace parenthetical text.\n\t\t\t\tforward_dict[term.id] = words\n\t\t\t\tfor word in words:\n\t\t\t\t\treverse_dict[word].append(term.id)\n\t\treturn(forward_dict, reverse_dict)","def get_ordered_vocabulary(self):\n idx_rev = dict((y, x) for x, y in self.ngram_to_idx.items())\n ordered_vocab = list(map(lambda i: idx_rev[i], range(len(self.vocab))))\n return ordered_vocab","def vocabulary(self):\n lst = []\n for key in self.frequencies().keys():\n lst.append(key)\n return sorted(lst)\n #for lines in self.lines:\n # line = lines.strip(os.linesep)\n # wordslst = line.split()\n # for word in wordslst:\n # if word not in lst:\n # lst.append(word.lower())\n #return sorted(lst)","def load_reverse_dict(dict_path):\n result_dict = {}\n # TODO 字和词模型\n for idx, line in enumerate(io.open(dict_path, \"r\", encoding='utf8')):\n terms = line.strip(\"\\n\")\n result_dict[terms] = idx\n return result_dict","def invert(self):\n return _({self[k]: k for k in self._})","def build_vocab(sentences, saved_vocabulary_inv):\n if saved_vocabulary_inv:\n vocabulary_inv = saved_vocabulary_inv\n else:\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def generate_vocabulary():\n stop_words = load_stop_words()\n words = ' '.join(generate_corpus()).split()\n print(len(words))\n vocabulary = {}\n for word in words:\n if word in stop_words:\n continue\n if word in vocabulary.keys():\n vocabulary[word] += 1\n else:\n vocabulary[word] = 1\n vocabulary = dict(sorted(vocabulary.items(), key=lambda x: x[1], reverse=True))\n return vocabulary","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"rb\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"rb\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def get_dict(self):\n return {key: value for key, value in zip(self._words, self._vecs)}","def getVocabulary(self): # real signature unknown; restored from __doc__\n pass","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"rb\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"r\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"rb\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [tf.compat.as_bytes(line.strip()) for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def initialize_vocabulary(vocabulary_path):\n if gfile.Exists(vocabulary_path):\n rev_vocab = []\n with gfile.GFile(vocabulary_path, mode=\"r\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def get_vocab(self):\n word2id = {}\n for document in self.docs:\n for word in document:\n if word not in word2id.keys():\n word2id[word] = len(word2id)\n return word2id","def initialize_vocabulary(vocabulary_path):\n if os.path.exists(vocabulary_path):\n rev_vocab = []\n with codecs_open(vocabulary_path, \"rb\", encoding=\"utf-8\") as f:\n rev_vocab.extend(f.readlines())\n rev_vocab = [line.strip() for line in rev_vocab]\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\n return vocab, rev_vocab\n else:\n raise ValueError(\"Vocabulary file %s not found.\", vocabulary_path)","def getVocabularyDict(vocabulary: dict, training_feature: TrainingFeature):\n vocab = {}\n index = 0\n if training_feature.FEATURE_DROP_FREQUENT_WORDS:\n print(\"Select vocabdict with drop_frequent\")\n array = sorted([(k, v) for (k, v) in vocabulary.items()], key= lambda x: x[1])\n print(\"Total length: \", len(array))\n length = len(array)\n array = array[int(length * 0.75): int(length * 1.0)][0:training_feature.VOCAB_SIZE]\n for (k , _) in array:\n vocab.setdefault(k, index)\n index += 1\n else:\n print(\"Select vocabdict with non_drop_frequent\")\n array = sorted([(k, v) for (k, v) in vocabulary.items()], key=lambda x: x[1])\n length = len(array)\n print(\"Total length: \", length)\n array = array[-training_feature.VOCAB_SIZE:]\n for (k, _) in array:\n vocab.setdefault(k, index)\n index += 1\n # for (k, v) in vocabulary.items():\n # if v > 50:\n # vocab.setdefault(k, index)\n # index += 1\n print(\"VocabDict length: \", len(vocab))\n # print(vocab)\n return vocab","def reverse_iteritems(self):\n return self._reverse_store.iteritems()","def invertDictionary(input_dict):\n inverse_dict = {v: k for k, v in input_dict.items()}\n\n return inverse_dict","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences)) # 实际没用到\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n vocabulary_inv = list(sorted(vocabulary_inv))\n # 加入 <UNK>\n vocabulary_inv.insert(0, '</s>')\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def reverse_values(self):\n return self._reverse_store.values()","def get_output_vocab():\n vocab = set(list(string.digits) + [':'])\n\n inv = dict(enumerate(sorted(vocab)))\n output = {v:k for k,v in inv.items()}\n return output, inv","def getVocabulary(vocabulary_id):\n relex_web = getSite().restrictedTraverse('relex_web')\n key = KEY_STORAGE + \".\" + vocabulary_id\n vocabulary = json.loads(getattr(relex_web, key, \"[]\"))\n return vocabulary","def get_vocab(self):\n\n\t\tself.parse_transcript() \n\t\tself.purge_words()\n\t\tself.analyze_words()\n\t\tself.sort_word_analysis()","def get_vocab(self):\n if os.path.exists(self.vocab_file) & self.vocab_from_file:\n f = open(self.vocab_file, \"rb\")\n vocab = pickle.load(f)\n self.word2idx = vocab.word2idx\n self.idx2word = vocab.idx2word\n f.close()\n else:\n self.build_vocab()\n with open(self.vocab_file, 'wb') as f:\n pickle.dump(self, f)","def _get_vocabulary(connection):\n print('---Getting vocabulary---')\n vocabulary = {}\n cursor = connection.cursor()\n cursor.execute(\"SELECT * FROM words;\")\n res = cursor.fetchall()\n num_words = 0\n for word in res:\n vocabulary[word[0]] = num_words\n num_words += 1\n return vocabulary","def revert_dictionary(dictionary):\n return {v: k for k, v in dictionary.items()}","def _load_vocabulary(self) -> Dict[str, int]:\n\n df_existing_vocab = self._db_connection.get_dataframe(table_name='tfidf_vocabulary', schema='encoded_articles')\n\n df_existing_vocab.set_index('word', inplace=True)\n\n return df_existing_vocab['feature_matrix_index'].to_dict()","def decode(self, seq):\n return [ self.rev_vocab[int(el)] for el in seq ]","def load_vocab(vocab_file):\n index = 0\n itos = {}\n stoi = {}\n with open(vocab_file, \"r\") as reader:\n while True:\n token = reader.readline()\n if not token:\n break\n token = token.strip()\n itos[index] = token\n stoi[token] = index\n index += 1\n itos[index] = 'style_options'\n stoi['style_options'] = index\n itos[index+1] = 'ambience'\n stoi['ambience'] = index + 1\n return {'itos': itos, 'stoi': stoi, 'len': len(itos)}","def _create_deleted_variation_2_dictionary_words(self):\n deleted_variation_2_dictionary_words = defaultdict(set)\n for word in self._word_2_frequency.keys():\n deleted_variations = chain(self._one_edit_deleted_variations(word), self._two_edits_deleted_variations(word))\n for deleted_variation in deleted_variations:\n deleted_variation_2_dictionary_words[deleted_variation].add(word)\n return deleted_variation_2_dictionary_words","def load_vocab(self):\n keys = []\n values = []\n with open(self.embed_file, 'r') as f:\n lines = f.readlines()\n\n for line in lines:\n key = line.split(\" \")[0]\n value = line.split(\" \")[1:]\n keys.append(key)\n values.append(value)\n # form <dict>\n # vocab = dict(zip(keys, values))\n return keys, values","def load(cls, w2v_vocab):\n n2v_vocab = cls()\n for key, value in w2v_vocab.__dict__.items():\n setattr(n2v_vocab, key, value)\n return n2v_vocab","def get_encoding_dict(self) -> Dict[str, int]:\n return {k.lower():v for v,k in enumerate(self.vocabulary_list)}","def vocab(self) -> Vocabulary:\n return self._model.vocab","def reverse_itervalues(self):\n return self._reverse_store.itervalues()","def vocabulary(self, config=Config()):\n raise NotImplementedError(\"Class %s doesn't implement vocabulary()\" % self.__class__.__name__)","def InvertDict(dict_in):\n return dict(zip(dict_in.values(), dict_in.keys()))","def create(self, vocabulary=list) -> dict:\n try:\n out = {}\n for i in range(len(vocabulary)):\n out[vocabulary[i]] = i\n return(out)\n except Exception as error:\n print(f\"Error: self.create([...]) -> {error}\")","def build_vocab(words, vocab_size, visual_fld=None):\n utils.safe_mkdir(visual_fld)\n file = open(os.path.join(visual_fld, 'vocab.tsv'), 'w',encoding='utf8')\n\n dictionary = dict()\n count = [('UNK', -1)]\n index = 0\n count.extend(Counter(words).most_common(vocab_size - 1))\n\n for word, _ in count:\n dictionary[word] = index\n index += 1\n file.write(word + '\\n')\n\n index_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n file.close()\n return dictionary, index_dictionary","def loadVoc(vocabFName):\n f = open(vocabFName, 'r')\n lines = f.readlines()\n f.close()\n result = dict()\n for idx, val in enumerate(lines):\n word = val.strip('\\n')\n result[word] = idx\n return result","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n vocabulary_inv = list(sorted(vocabulary_inv))\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def text2vec(self, maxlen):\n # Vocab = {word : index}\n self.Vocab = dict()\n\n for SentenceLabel in self.Pos + self.Neg:\n vector = [0] * maxlen\n for index, word in enumerate(SentenceLabel[0]):\n if index >= maxlen:\n break\n if word not in self.Vocab.keys():\n self.Vocab[word] = len(self.Vocab)\n vector[index] = len(self.Vocab) - 1\n else:\n vector[index] = self.Vocab[word]\n SentenceLabel[0] = vector\n self.doConvert = True","def construct_dict(self):\n i = 0\n self.word2idx = dict()\n fi = open(self.config.word_vec_fi_glove, 'r')\n\n for line in fi:\n self.word2idx[line.split(\" \")[0]] = i\n i += 1\n\n self.vocab_size = i\n self.write_dict()\n fi.close()","def load_vocab(fn):\n return corpora.Dictionary.load(fn)","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def load_vocabulary():\n global vocabulary_list, vocabulary_dict\n vocabulary_list = []\n vocabulary_dict = {}\n\n with open(_VOCABULARY_PATH, 'r') as f:\n for index, line in enumerate(f):\n line = line.strip()\n vocabulary_dict[line] = index\n vocabulary_list.append(line)","def read_vocabulary(vocabulary_id):\n query = (\n select([vocabulary_table])\n .where(vocabulary_table.c.id == vocabulary_id))\n res = query.execute().first()\n if res is not None:\n return dict(res)","def _create_dictionary(self, document):\n words = self._normalize_words(document.words)\n unique_words = frozenset(words)\n return dict((word, idx) for idx, word in enumerate(unique_words))","def create_ngram_dict(min_ngram=1, max_ngram=3, filename='./resources/vocabulary.json'):\n db_labels = get_labels_from_db()\n vocabulary = filter_ngram_labels(db_labels, min_ngram, max_ngram)\n save_dict_as_json(vocabulary, filename)\n return vocabulary","def vocab(self):\n num_words = -1\n if not self._vocab:\n c = self._conn.cursor()\n c.execute('select feature, censored, word_id from vocab')\n\n d = {}\n for ww, cc, ii in c:\n d[ii] = ww\n d[ww] = ii\n if cc == 1:\n self._censored.add(ww)\n num_words = max(ii, num_words)\n\n logger.info(\"Loaded vocab with %i words; %i censored\" % \\\n (len(d) / 2, len(self._censored)))\n\n # Add the start symbol\n if not START_SYMBOL in d:\n d[START_SYMBOL] = num_words + 1\n d[num_words + 1] = START_SYMBOL\n\n logger.info(\"Retrieved %i words\" % num_words)\n self._vocab = d\n\n return self._vocab","def vocab():\n symbols = DEFAULT_SPECIAL_SYMBOLS + [\"mouse\", \"dog\", \"tree\"]\n return Vocabulary(symbols)","def reverse_enum(\n enum_to_reverse: Union[\n Type[SMOOTHIE_G_CODE],\n Type[MAGDECK_G_CODE],\n Type[TEMPDECK_G_CODE],\n Type[THERMOCYCLER_G_CODE],\n Type[HEATER_SHAKER_G_CODE],\n ]\n) -> Dict:\n # I don't know what is going on with mypy, it is complaining\n # about keys not existing as an attribute. I am not calling it\n # as an attribute. I am calling it as a function.\n members = enum_to_reverse.__members__.keys()\n values = [enum_to_reverse[member] for member in members]\n return dict(zip(values, members))","def reversed_face(self):\n return Face(self.topods_shape().Reversed())","def to_json(self) -> str:\n vocab_dict = dict()\n # Perform sanity check to make sure that we are able to reconstruct the original vocab\n for i, tok in enumerate(self._all_tokens):\n if self._token_to_idx[tok] != i:\n warnings.warn('The vocabulary is corrupted! One possible reason is that the '\n 'tokens are changed manually without updating the '\n '_token_to_idx map. Please check your code or report an issue in '\n 'Github!')\n vocab_dict['all_tokens'] = self._all_tokens\n vocab_dict['special_token_key_value'] = self._special_token_kv\n ret = json.dumps(vocab_dict, ensure_ascii=False)\n return ret","def reverse_items(self):\n return self._reverse_store.items()","def build_vocab(sentences_list, vocab_size, visual_fld):\n words = [word for sentence in sentences_list for word in sentence]\n utils.safe_mkdir(visual_fld)\n with open(os.path.join(visual_fld, 'vocab.tsv'), 'w') as fd:\n dictionary = {}\n index_dictionary = {}\n count = [('UNK', -1)]\n count.extend(Counter(words).most_common(vocab_size - 1))\n for index, (word, _) in enumerate(count):\n dictionary[word] = index\n index_dictionary[index] = word\n fd.write(word + '\\n')\n\n return dictionary, index_dictionary","def get_input_vocab():\n vocab = set()\n vocab.update(list(string.ascii_letters))\n vocab.update(list(string.digits))\n vocab.update(list(string.punctuation))\n vocab.update(list(string.whitespace))\n vocab.update(['<unk>', '<pad>'])\n return dict(zip(sorted(vocab), list(range(len(vocab)))))","def rev_dict(input_dict):\n return_dict = {}\n for i, j in input_dict.items():\n return_dict[abs(j)] = i\n return return_dict","def convertToDict(self): \n out = dict() \n out[\"Title\"] = self.title \n editions = []\n for edition in self.editions.values(): \n editions.append(edition.convertToDict(withTitle = False))\n out[\"Editions\"] = editions\n return out","def test_dict_ancestor_and_reversed():\n from collections import OrderedDict\n\n class Child(dict):\n def __reversed__(self):\n return reversed(range(10))\n\n seq = reversed(OrderedDict())\n return reversed(Child()), seq","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common() if x[1] > 1]\n vocabulary_inv += ['$']\n vocabulary_inv = list(sorted(vocabulary_inv))\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def load_vocab():\n # vocab loaded internally at google\n unused = r.sp_model\n del unused\n return r","def load_vocab(vocab_file):\n vocab = collections.OrderedDict()\n index = 0\n with open(vocab_file, \"r\", encoding=\"utf-8\") as reader:\n while True:\n token = reader.readline()\n if not token:\n break\n token = token.strip()\n vocab[token] = index\n index += 1\n return vocab","def load_vocab(vocab_file):\n vocab = collections.OrderedDict()\n index = 0\n with open(vocab_file, \"r\", encoding=\"utf-8\") as reader:\n while True:\n token = reader.readline()\n if not token:\n break\n token = token.strip()\n vocab[token] = index\n index += 1\n return vocab","def read_dictionary():\n with open(FILE, 'r') as f:\n for vocabulary in f:\n if vocabulary[0].strip() not in dict_txt:\n dict_txt[vocabulary[0].strip()] = [vocabulary.strip()]\n else:\n dict_txt[vocabulary[0].strip()].append(vocabulary.strip())","def build_vocab(sentences):\n # Build vocabulary\n word_counts = Counter(itertools.chain(*sentences))\n # Mapping from index to word\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\n vocabulary_inv.append('<pad>')\n vocabulary_inv = list(sorted(vocabulary_inv))\n # Mapping from word to index\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\n return [vocabulary, vocabulary_inv]","def invert_dictionary(dictionary):\n inverted = {}\n for key in dictionary:\n inverted[dictionary[key]] = key\n return inverted","def from_dict(cls, dikt: dict) -> 'Vocabulary':\n return util.deserialize_model(dikt, cls)","def deserialize(self, descriptor: Dict, data: List) -> ObjectHandle:\n return VocabularyHandle(\n values=set(data),\n name=descriptor['name'],\n namespace=descriptor['namespace'],\n label=descriptor.get('label'),\n description=descriptor.get('description')\n )","def write_vocabulary(vocab_processor, outfile):\n vocab_size = len(vocab_processor.vocabulary_)\n with open(outfile, \"w\") as vocabfile:\n for id in range(vocab_size):\n word = vocab_processor.vocabulary_._reverse_mapping[id]\n vocabfile.write(word + \"\\n\")\n print(\"Saved vocabulary to {}\".format(outfile))","def __repr__(self):\n l1 = \", \".join(\"{}={}\".format(x,y) for x,y in self._loading_params.items())\n l2 = \"max_vocab_size={}, min_token_freq={}, max_token_freq={}, ngrams={}\".format(\n self._max_vocab_size if hasattr(self, \"_max_vocab_size\") else None,\n self._min_token_freq if hasattr(self, \"_min_token_freq\") else 0,\n self._max_token_freq if hasattr(self, \"_max_token_freq\") else None,\n self._ngrams if hasattr(self, \"_ngrams\") else [1,1]\n )\n desc = \"Vocabulary({}, {})\".format(l1, l2)\n return desc","def vocab_from_pickle(path: str) -> Dict:\n with open(path, \"rb\") as inp:\n vocab = pickle.load(inp)\n logger.info('Vocabulary (%d words) loaded from \"%s\"', len(vocab), path)\n return vocab","def get_vocab(which_vocab):\n path = os.path.join(mg.WORKING_PATH, 'vocab', ''.join([which_vocab, '.json'\n ]))\n if os.path.exists(path):\n with open(path, 'r') as js:\n return(json.load(js))\n else:\n return(dict())","def to_dict(self) -> dict:\n return dict(sentences=[sentence.to_dict() for sentence in self.sentences])","def reverse(self):\n cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)\n openfst.Reverse(self.fst[0], result.fst)\n return result","def make_vocab(corpus_dictionary, vocab_path):\n with open(vocab_path, 'wb') as fout:\n pickle.dump(corpus_dictionary, fout)\n print('Saved dictionary to', vocab_path)","def load_vocab(vocab):\r\n\tvocab = [line.split()[0] for line in open(\r\n\t\t'{}{}'.format(pm.vocab_path, vocab), 'r', encoding='utf-8').read().splitlines()\r\n\t\t\t if int(line.split()[1]) >= pm.word_limit_size]\r\n\tword2idx_dic = {word: idx for idx, word in enumerate(vocab)}\r\n\tidx2word_dic = {idx: word for idx, word in enumerate(vocab)}\r\n\treturn word2idx_dic, idx2word_dic","def reverse_indices(indices, rev_vocab):\n return ' '.join([rev_vocab[idx] for idx in indices if idx != PAD_ID])","def load_vocab(vocab_file):\n vocab = collections.OrderedDict()\n with open(vocab_file, \"r\", encoding=\"utf-8\") as reader:\n tokens = reader.readlines()\n for index, token in enumerate(tokens):\n token = token.rstrip('\\n')\n vocab[token] = index\n return vocab","def one_hot_vocab_encoding(w2vp: W2VPreprocessor \n ) -> Dict[str, np.ndarray]:\n return {\n w: i for i, w in enumerate(w2vp.vocabulary)\n }","def copy(self):\n s = sppasVocabulary()\n for i in self.__entries:\n s.add(i)\n\n return s","def load_vocab(vocab_file, encoding='utf8'):\n vocab = OrderedDict()\n index = 0\n with open(vocab_file, encoding=encoding) as reader:\n while True:\n token = convert_to_unicode(reader.readline())\n if not token:\n break\n token = token.strip()\n vocab[token] = index\n index += 1\n return vocab","def load_vocab(vocab_file):\n vocab = collections.OrderedDict()\n index = 0\n with tf.gfile.GFile(vocab_file, \"r\") as reader:\n while True:\n token = convert_to_unicode(reader.readline())\n if not token:\n break\n token = token.strip()\n vocab[token] = index\n index += 1\n return vocab","def load_vocab(filename):\n try:\n d = dict()\n with open(filename, encoding='utf-8') as f:\n for idx, word in enumerate(f):\n word = word.strip()\n d[word] = idx\n\n except IOError:\n raise MyIOError(filename)\n return d"],"string":"[\n \"def reverse_vocab(vocab: Dict[str, int]) -> Dict[int, str]:\\n return {v: k for k, v in vocab.items()}\",\n \"def reverse_dicts(self):\\n\\t\\tself.rev_worddict = {self.worddict[word]: word for word in self.worddict}\\n\\t\\tself.rev_classdict = {self.classdict[cl]: cl for cl in self.classdict}\",\n \"def __reversed__(self):\\n\\t\\treturn reversed(self.__dict__.values())\",\n \"def reverse(dictionary):\\n return {b: a for a, b in dictionary.items()}\",\n \"def generate_vocab_dict(vocab):\\n v_dict = {}\\n for word in vocab:\\n if len(word) in v_dict:\\n v_dict[len(word)].append(word)\\n else:\\n v_dict[len(word)] = [word]\\n return v_dict\",\n \"def _rev_dict(d):\\n return {v: k for k, v in d.items()}\",\n \"def reverse_word_index(word_index):\\n return dict([(word_index[word], word) for word in word_index])\",\n \"def vocabulary(self):\\n return self._vocabulary\",\n \"def as_dict(self):\\r\\n return {self.words[i]: self.vectors[i] for i in range(self.n)}\",\n \"def build_reverse_dictionary(word_to_id):\\n reverse_dictionary = dict(zip(word_to_id.values(), word_to_id.keys()))\\n return reverse_dictionary\",\n \"def vocabulary(self):\\n return [recid for recid in self._model.vocab]\",\n \"def _get_term_dictionaries(self):\\n\\t\\tforward_dict = {}\\n\\t\\treverse_dict = defaultdict(list)\\n\\t\\tfor term in self.terms():\\n\\t\\t\\tif (term.name is not None) and (\\\"obsolete\\\" not in term.name): \\n\\t\\t\\t\\twords = [term.name]\\n\\t\\t\\t\\twords.extend([x.description for x in list(term.synonyms)])\\t# Add all the synonyms\\n\\t\\t\\t\\twords = [re.sub(r\\\" ?\\\\([^)]+\\\\)\\\", \\\"\\\", x) for x in words]\\t\\t# Replace parenthetical text.\\n\\t\\t\\t\\tforward_dict[term.id] = words\\n\\t\\t\\t\\tfor word in words:\\n\\t\\t\\t\\t\\treverse_dict[word].append(term.id)\\n\\t\\treturn(forward_dict, reverse_dict)\",\n \"def get_ordered_vocabulary(self):\\n idx_rev = dict((y, x) for x, y in self.ngram_to_idx.items())\\n ordered_vocab = list(map(lambda i: idx_rev[i], range(len(self.vocab))))\\n return ordered_vocab\",\n \"def vocabulary(self):\\n lst = []\\n for key in self.frequencies().keys():\\n lst.append(key)\\n return sorted(lst)\\n #for lines in self.lines:\\n # line = lines.strip(os.linesep)\\n # wordslst = line.split()\\n # for word in wordslst:\\n # if word not in lst:\\n # lst.append(word.lower())\\n #return sorted(lst)\",\n \"def load_reverse_dict(dict_path):\\n result_dict = {}\\n # TODO 字和词模型\\n for idx, line in enumerate(io.open(dict_path, \\\"r\\\", encoding='utf8')):\\n terms = line.strip(\\\"\\\\n\\\")\\n result_dict[terms] = idx\\n return result_dict\",\n \"def invert(self):\\n return _({self[k]: k for k in self._})\",\n \"def build_vocab(sentences, saved_vocabulary_inv):\\n if saved_vocabulary_inv:\\n vocabulary_inv = saved_vocabulary_inv\\n else:\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def generate_vocabulary():\\n stop_words = load_stop_words()\\n words = ' '.join(generate_corpus()).split()\\n print(len(words))\\n vocabulary = {}\\n for word in words:\\n if word in stop_words:\\n continue\\n if word in vocabulary.keys():\\n vocabulary[word] += 1\\n else:\\n vocabulary[word] = 1\\n vocabulary = dict(sorted(vocabulary.items(), key=lambda x: x[1], reverse=True))\\n return vocabulary\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"rb\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"rb\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def get_dict(self):\\n return {key: value for key, value in zip(self._words, self._vecs)}\",\n \"def getVocabulary(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"rb\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"r\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"rb\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [tf.compat.as_bytes(line.strip()) for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def initialize_vocabulary(vocabulary_path):\\n if gfile.Exists(vocabulary_path):\\n rev_vocab = []\\n with gfile.GFile(vocabulary_path, mode=\\\"r\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def get_vocab(self):\\n word2id = {}\\n for document in self.docs:\\n for word in document:\\n if word not in word2id.keys():\\n word2id[word] = len(word2id)\\n return word2id\",\n \"def initialize_vocabulary(vocabulary_path):\\n if os.path.exists(vocabulary_path):\\n rev_vocab = []\\n with codecs_open(vocabulary_path, \\\"rb\\\", encoding=\\\"utf-8\\\") as f:\\n rev_vocab.extend(f.readlines())\\n rev_vocab = [line.strip() for line in rev_vocab]\\n vocab = dict([(x, y) for (y, x) in enumerate(rev_vocab)])\\n return vocab, rev_vocab\\n else:\\n raise ValueError(\\\"Vocabulary file %s not found.\\\", vocabulary_path)\",\n \"def getVocabularyDict(vocabulary: dict, training_feature: TrainingFeature):\\n vocab = {}\\n index = 0\\n if training_feature.FEATURE_DROP_FREQUENT_WORDS:\\n print(\\\"Select vocabdict with drop_frequent\\\")\\n array = sorted([(k, v) for (k, v) in vocabulary.items()], key= lambda x: x[1])\\n print(\\\"Total length: \\\", len(array))\\n length = len(array)\\n array = array[int(length * 0.75): int(length * 1.0)][0:training_feature.VOCAB_SIZE]\\n for (k , _) in array:\\n vocab.setdefault(k, index)\\n index += 1\\n else:\\n print(\\\"Select vocabdict with non_drop_frequent\\\")\\n array = sorted([(k, v) for (k, v) in vocabulary.items()], key=lambda x: x[1])\\n length = len(array)\\n print(\\\"Total length: \\\", length)\\n array = array[-training_feature.VOCAB_SIZE:]\\n for (k, _) in array:\\n vocab.setdefault(k, index)\\n index += 1\\n # for (k, v) in vocabulary.items():\\n # if v > 50:\\n # vocab.setdefault(k, index)\\n # index += 1\\n print(\\\"VocabDict length: \\\", len(vocab))\\n # print(vocab)\\n return vocab\",\n \"def reverse_iteritems(self):\\n return self._reverse_store.iteritems()\",\n \"def invertDictionary(input_dict):\\n inverse_dict = {v: k for k, v in input_dict.items()}\\n\\n return inverse_dict\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences)) # 实际没用到\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n vocabulary_inv = list(sorted(vocabulary_inv))\\n # 加入 <UNK>\\n vocabulary_inv.insert(0, '</s>')\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def reverse_values(self):\\n return self._reverse_store.values()\",\n \"def get_output_vocab():\\n vocab = set(list(string.digits) + [':'])\\n\\n inv = dict(enumerate(sorted(vocab)))\\n output = {v:k for k,v in inv.items()}\\n return output, inv\",\n \"def getVocabulary(vocabulary_id):\\n relex_web = getSite().restrictedTraverse('relex_web')\\n key = KEY_STORAGE + \\\".\\\" + vocabulary_id\\n vocabulary = json.loads(getattr(relex_web, key, \\\"[]\\\"))\\n return vocabulary\",\n \"def get_vocab(self):\\n\\n\\t\\tself.parse_transcript() \\n\\t\\tself.purge_words()\\n\\t\\tself.analyze_words()\\n\\t\\tself.sort_word_analysis()\",\n \"def get_vocab(self):\\n if os.path.exists(self.vocab_file) & self.vocab_from_file:\\n f = open(self.vocab_file, \\\"rb\\\")\\n vocab = pickle.load(f)\\n self.word2idx = vocab.word2idx\\n self.idx2word = vocab.idx2word\\n f.close()\\n else:\\n self.build_vocab()\\n with open(self.vocab_file, 'wb') as f:\\n pickle.dump(self, f)\",\n \"def _get_vocabulary(connection):\\n print('---Getting vocabulary---')\\n vocabulary = {}\\n cursor = connection.cursor()\\n cursor.execute(\\\"SELECT * FROM words;\\\")\\n res = cursor.fetchall()\\n num_words = 0\\n for word in res:\\n vocabulary[word[0]] = num_words\\n num_words += 1\\n return vocabulary\",\n \"def revert_dictionary(dictionary):\\n return {v: k for k, v in dictionary.items()}\",\n \"def _load_vocabulary(self) -> Dict[str, int]:\\n\\n df_existing_vocab = self._db_connection.get_dataframe(table_name='tfidf_vocabulary', schema='encoded_articles')\\n\\n df_existing_vocab.set_index('word', inplace=True)\\n\\n return df_existing_vocab['feature_matrix_index'].to_dict()\",\n \"def decode(self, seq):\\n return [ self.rev_vocab[int(el)] for el in seq ]\",\n \"def load_vocab(vocab_file):\\n index = 0\\n itos = {}\\n stoi = {}\\n with open(vocab_file, \\\"r\\\") as reader:\\n while True:\\n token = reader.readline()\\n if not token:\\n break\\n token = token.strip()\\n itos[index] = token\\n stoi[token] = index\\n index += 1\\n itos[index] = 'style_options'\\n stoi['style_options'] = index\\n itos[index+1] = 'ambience'\\n stoi['ambience'] = index + 1\\n return {'itos': itos, 'stoi': stoi, 'len': len(itos)}\",\n \"def _create_deleted_variation_2_dictionary_words(self):\\n deleted_variation_2_dictionary_words = defaultdict(set)\\n for word in self._word_2_frequency.keys():\\n deleted_variations = chain(self._one_edit_deleted_variations(word), self._two_edits_deleted_variations(word))\\n for deleted_variation in deleted_variations:\\n deleted_variation_2_dictionary_words[deleted_variation].add(word)\\n return deleted_variation_2_dictionary_words\",\n \"def load_vocab(self):\\n keys = []\\n values = []\\n with open(self.embed_file, 'r') as f:\\n lines = f.readlines()\\n\\n for line in lines:\\n key = line.split(\\\" \\\")[0]\\n value = line.split(\\\" \\\")[1:]\\n keys.append(key)\\n values.append(value)\\n # form <dict>\\n # vocab = dict(zip(keys, values))\\n return keys, values\",\n \"def load(cls, w2v_vocab):\\n n2v_vocab = cls()\\n for key, value in w2v_vocab.__dict__.items():\\n setattr(n2v_vocab, key, value)\\n return n2v_vocab\",\n \"def get_encoding_dict(self) -> Dict[str, int]:\\n return {k.lower():v for v,k in enumerate(self.vocabulary_list)}\",\n \"def vocab(self) -> Vocabulary:\\n return self._model.vocab\",\n \"def reverse_itervalues(self):\\n return self._reverse_store.itervalues()\",\n \"def vocabulary(self, config=Config()):\\n raise NotImplementedError(\\\"Class %s doesn't implement vocabulary()\\\" % self.__class__.__name__)\",\n \"def InvertDict(dict_in):\\n return dict(zip(dict_in.values(), dict_in.keys()))\",\n \"def create(self, vocabulary=list) -> dict:\\n try:\\n out = {}\\n for i in range(len(vocabulary)):\\n out[vocabulary[i]] = i\\n return(out)\\n except Exception as error:\\n print(f\\\"Error: self.create([...]) -> {error}\\\")\",\n \"def build_vocab(words, vocab_size, visual_fld=None):\\n utils.safe_mkdir(visual_fld)\\n file = open(os.path.join(visual_fld, 'vocab.tsv'), 'w',encoding='utf8')\\n\\n dictionary = dict()\\n count = [('UNK', -1)]\\n index = 0\\n count.extend(Counter(words).most_common(vocab_size - 1))\\n\\n for word, _ in count:\\n dictionary[word] = index\\n index += 1\\n file.write(word + '\\\\n')\\n\\n index_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\\n file.close()\\n return dictionary, index_dictionary\",\n \"def loadVoc(vocabFName):\\n f = open(vocabFName, 'r')\\n lines = f.readlines()\\n f.close()\\n result = dict()\\n for idx, val in enumerate(lines):\\n word = val.strip('\\\\n')\\n result[word] = idx\\n return result\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n vocabulary_inv = list(sorted(vocabulary_inv))\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def text2vec(self, maxlen):\\n # Vocab = {word : index}\\n self.Vocab = dict()\\n\\n for SentenceLabel in self.Pos + self.Neg:\\n vector = [0] * maxlen\\n for index, word in enumerate(SentenceLabel[0]):\\n if index >= maxlen:\\n break\\n if word not in self.Vocab.keys():\\n self.Vocab[word] = len(self.Vocab)\\n vector[index] = len(self.Vocab) - 1\\n else:\\n vector[index] = self.Vocab[word]\\n SentenceLabel[0] = vector\\n self.doConvert = True\",\n \"def construct_dict(self):\\n i = 0\\n self.word2idx = dict()\\n fi = open(self.config.word_vec_fi_glove, 'r')\\n\\n for line in fi:\\n self.word2idx[line.split(\\\" \\\")[0]] = i\\n i += 1\\n\\n self.vocab_size = i\\n self.write_dict()\\n fi.close()\",\n \"def load_vocab(fn):\\n return corpora.Dictionary.load(fn)\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def load_vocabulary():\\n global vocabulary_list, vocabulary_dict\\n vocabulary_list = []\\n vocabulary_dict = {}\\n\\n with open(_VOCABULARY_PATH, 'r') as f:\\n for index, line in enumerate(f):\\n line = line.strip()\\n vocabulary_dict[line] = index\\n vocabulary_list.append(line)\",\n \"def read_vocabulary(vocabulary_id):\\n query = (\\n select([vocabulary_table])\\n .where(vocabulary_table.c.id == vocabulary_id))\\n res = query.execute().first()\\n if res is not None:\\n return dict(res)\",\n \"def _create_dictionary(self, document):\\n words = self._normalize_words(document.words)\\n unique_words = frozenset(words)\\n return dict((word, idx) for idx, word in enumerate(unique_words))\",\n \"def create_ngram_dict(min_ngram=1, max_ngram=3, filename='./resources/vocabulary.json'):\\n db_labels = get_labels_from_db()\\n vocabulary = filter_ngram_labels(db_labels, min_ngram, max_ngram)\\n save_dict_as_json(vocabulary, filename)\\n return vocabulary\",\n \"def vocab(self):\\n num_words = -1\\n if not self._vocab:\\n c = self._conn.cursor()\\n c.execute('select feature, censored, word_id from vocab')\\n\\n d = {}\\n for ww, cc, ii in c:\\n d[ii] = ww\\n d[ww] = ii\\n if cc == 1:\\n self._censored.add(ww)\\n num_words = max(ii, num_words)\\n\\n logger.info(\\\"Loaded vocab with %i words; %i censored\\\" % \\\\\\n (len(d) / 2, len(self._censored)))\\n\\n # Add the start symbol\\n if not START_SYMBOL in d:\\n d[START_SYMBOL] = num_words + 1\\n d[num_words + 1] = START_SYMBOL\\n\\n logger.info(\\\"Retrieved %i words\\\" % num_words)\\n self._vocab = d\\n\\n return self._vocab\",\n \"def vocab():\\n symbols = DEFAULT_SPECIAL_SYMBOLS + [\\\"mouse\\\", \\\"dog\\\", \\\"tree\\\"]\\n return Vocabulary(symbols)\",\n \"def reverse_enum(\\n enum_to_reverse: Union[\\n Type[SMOOTHIE_G_CODE],\\n Type[MAGDECK_G_CODE],\\n Type[TEMPDECK_G_CODE],\\n Type[THERMOCYCLER_G_CODE],\\n Type[HEATER_SHAKER_G_CODE],\\n ]\\n) -> Dict:\\n # I don't know what is going on with mypy, it is complaining\\n # about keys not existing as an attribute. I am not calling it\\n # as an attribute. I am calling it as a function.\\n members = enum_to_reverse.__members__.keys()\\n values = [enum_to_reverse[member] for member in members]\\n return dict(zip(values, members))\",\n \"def reversed_face(self):\\n return Face(self.topods_shape().Reversed())\",\n \"def to_json(self) -> str:\\n vocab_dict = dict()\\n # Perform sanity check to make sure that we are able to reconstruct the original vocab\\n for i, tok in enumerate(self._all_tokens):\\n if self._token_to_idx[tok] != i:\\n warnings.warn('The vocabulary is corrupted! One possible reason is that the '\\n 'tokens are changed manually without updating the '\\n '_token_to_idx map. Please check your code or report an issue in '\\n 'Github!')\\n vocab_dict['all_tokens'] = self._all_tokens\\n vocab_dict['special_token_key_value'] = self._special_token_kv\\n ret = json.dumps(vocab_dict, ensure_ascii=False)\\n return ret\",\n \"def reverse_items(self):\\n return self._reverse_store.items()\",\n \"def build_vocab(sentences_list, vocab_size, visual_fld):\\n words = [word for sentence in sentences_list for word in sentence]\\n utils.safe_mkdir(visual_fld)\\n with open(os.path.join(visual_fld, 'vocab.tsv'), 'w') as fd:\\n dictionary = {}\\n index_dictionary = {}\\n count = [('UNK', -1)]\\n count.extend(Counter(words).most_common(vocab_size - 1))\\n for index, (word, _) in enumerate(count):\\n dictionary[word] = index\\n index_dictionary[index] = word\\n fd.write(word + '\\\\n')\\n\\n return dictionary, index_dictionary\",\n \"def get_input_vocab():\\n vocab = set()\\n vocab.update(list(string.ascii_letters))\\n vocab.update(list(string.digits))\\n vocab.update(list(string.punctuation))\\n vocab.update(list(string.whitespace))\\n vocab.update(['<unk>', '<pad>'])\\n return dict(zip(sorted(vocab), list(range(len(vocab)))))\",\n \"def rev_dict(input_dict):\\n return_dict = {}\\n for i, j in input_dict.items():\\n return_dict[abs(j)] = i\\n return return_dict\",\n \"def convertToDict(self): \\n out = dict() \\n out[\\\"Title\\\"] = self.title \\n editions = []\\n for edition in self.editions.values(): \\n editions.append(edition.convertToDict(withTitle = False))\\n out[\\\"Editions\\\"] = editions\\n return out\",\n \"def test_dict_ancestor_and_reversed():\\n from collections import OrderedDict\\n\\n class Child(dict):\\n def __reversed__(self):\\n return reversed(range(10))\\n\\n seq = reversed(OrderedDict())\\n return reversed(Child()), seq\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common() if x[1] > 1]\\n vocabulary_inv += ['$']\\n vocabulary_inv = list(sorted(vocabulary_inv))\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def load_vocab():\\n # vocab loaded internally at google\\n unused = r.sp_model\\n del unused\\n return r\",\n \"def load_vocab(vocab_file):\\n vocab = collections.OrderedDict()\\n index = 0\\n with open(vocab_file, \\\"r\\\", encoding=\\\"utf-8\\\") as reader:\\n while True:\\n token = reader.readline()\\n if not token:\\n break\\n token = token.strip()\\n vocab[token] = index\\n index += 1\\n return vocab\",\n \"def load_vocab(vocab_file):\\n vocab = collections.OrderedDict()\\n index = 0\\n with open(vocab_file, \\\"r\\\", encoding=\\\"utf-8\\\") as reader:\\n while True:\\n token = reader.readline()\\n if not token:\\n break\\n token = token.strip()\\n vocab[token] = index\\n index += 1\\n return vocab\",\n \"def read_dictionary():\\n with open(FILE, 'r') as f:\\n for vocabulary in f:\\n if vocabulary[0].strip() not in dict_txt:\\n dict_txt[vocabulary[0].strip()] = [vocabulary.strip()]\\n else:\\n dict_txt[vocabulary[0].strip()].append(vocabulary.strip())\",\n \"def build_vocab(sentences):\\n # Build vocabulary\\n word_counts = Counter(itertools.chain(*sentences))\\n # Mapping from index to word\\n vocabulary_inv = [x[0] for x in word_counts.most_common()]\\n vocabulary_inv.append('<pad>')\\n vocabulary_inv = list(sorted(vocabulary_inv))\\n # Mapping from word to index\\n vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}\\n return [vocabulary, vocabulary_inv]\",\n \"def invert_dictionary(dictionary):\\n inverted = {}\\n for key in dictionary:\\n inverted[dictionary[key]] = key\\n return inverted\",\n \"def from_dict(cls, dikt: dict) -> 'Vocabulary':\\n return util.deserialize_model(dikt, cls)\",\n \"def deserialize(self, descriptor: Dict, data: List) -> ObjectHandle:\\n return VocabularyHandle(\\n values=set(data),\\n name=descriptor['name'],\\n namespace=descriptor['namespace'],\\n label=descriptor.get('label'),\\n description=descriptor.get('description')\\n )\",\n \"def write_vocabulary(vocab_processor, outfile):\\n vocab_size = len(vocab_processor.vocabulary_)\\n with open(outfile, \\\"w\\\") as vocabfile:\\n for id in range(vocab_size):\\n word = vocab_processor.vocabulary_._reverse_mapping[id]\\n vocabfile.write(word + \\\"\\\\n\\\")\\n print(\\\"Saved vocabulary to {}\\\".format(outfile))\",\n \"def __repr__(self):\\n l1 = \\\", \\\".join(\\\"{}={}\\\".format(x,y) for x,y in self._loading_params.items())\\n l2 = \\\"max_vocab_size={}, min_token_freq={}, max_token_freq={}, ngrams={}\\\".format(\\n self._max_vocab_size if hasattr(self, \\\"_max_vocab_size\\\") else None,\\n self._min_token_freq if hasattr(self, \\\"_min_token_freq\\\") else 0,\\n self._max_token_freq if hasattr(self, \\\"_max_token_freq\\\") else None,\\n self._ngrams if hasattr(self, \\\"_ngrams\\\") else [1,1]\\n )\\n desc = \\\"Vocabulary({}, {})\\\".format(l1, l2)\\n return desc\",\n \"def vocab_from_pickle(path: str) -> Dict:\\n with open(path, \\\"rb\\\") as inp:\\n vocab = pickle.load(inp)\\n logger.info('Vocabulary (%d words) loaded from \\\"%s\\\"', len(vocab), path)\\n return vocab\",\n \"def get_vocab(which_vocab):\\n path = os.path.join(mg.WORKING_PATH, 'vocab', ''.join([which_vocab, '.json'\\n ]))\\n if os.path.exists(path):\\n with open(path, 'r') as js:\\n return(json.load(js))\\n else:\\n return(dict())\",\n \"def to_dict(self) -> dict:\\n return dict(sentences=[sentence.to_dict() for sentence in self.sentences])\",\n \"def reverse(self):\\n cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)\\n openfst.Reverse(self.fst[0], result.fst)\\n return result\",\n \"def make_vocab(corpus_dictionary, vocab_path):\\n with open(vocab_path, 'wb') as fout:\\n pickle.dump(corpus_dictionary, fout)\\n print('Saved dictionary to', vocab_path)\",\n \"def load_vocab(vocab):\\r\\n\\tvocab = [line.split()[0] for line in open(\\r\\n\\t\\t'{}{}'.format(pm.vocab_path, vocab), 'r', encoding='utf-8').read().splitlines()\\r\\n\\t\\t\\t if int(line.split()[1]) >= pm.word_limit_size]\\r\\n\\tword2idx_dic = {word: idx for idx, word in enumerate(vocab)}\\r\\n\\tidx2word_dic = {idx: word for idx, word in enumerate(vocab)}\\r\\n\\treturn word2idx_dic, idx2word_dic\",\n \"def reverse_indices(indices, rev_vocab):\\n return ' '.join([rev_vocab[idx] for idx in indices if idx != PAD_ID])\",\n \"def load_vocab(vocab_file):\\n vocab = collections.OrderedDict()\\n with open(vocab_file, \\\"r\\\", encoding=\\\"utf-8\\\") as reader:\\n tokens = reader.readlines()\\n for index, token in enumerate(tokens):\\n token = token.rstrip('\\\\n')\\n vocab[token] = index\\n return vocab\",\n \"def one_hot_vocab_encoding(w2vp: W2VPreprocessor \\n ) -> Dict[str, np.ndarray]:\\n return {\\n w: i for i, w in enumerate(w2vp.vocabulary)\\n }\",\n \"def copy(self):\\n s = sppasVocabulary()\\n for i in self.__entries:\\n s.add(i)\\n\\n return s\",\n \"def load_vocab(vocab_file, encoding='utf8'):\\n vocab = OrderedDict()\\n index = 0\\n with open(vocab_file, encoding=encoding) as reader:\\n while True:\\n token = convert_to_unicode(reader.readline())\\n if not token:\\n break\\n token = token.strip()\\n vocab[token] = index\\n index += 1\\n return vocab\",\n \"def load_vocab(vocab_file):\\n vocab = collections.OrderedDict()\\n index = 0\\n with tf.gfile.GFile(vocab_file, \\\"r\\\") as reader:\\n while True:\\n token = convert_to_unicode(reader.readline())\\n if not token:\\n break\\n token = token.strip()\\n vocab[token] = index\\n index += 1\\n return vocab\",\n \"def load_vocab(filename):\\n try:\\n d = dict()\\n with open(filename, encoding='utf-8') as f:\\n for idx, word in enumerate(f):\\n word = word.strip()\\n d[word] = idx\\n\\n except IOError:\\n raise MyIOError(filename)\\n return d\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77923155","0.6690991","0.6248791","0.6209789","0.6155369","0.6095056","0.60796165","0.60738266","0.606323","0.60227686","0.6020329","0.5977967","0.5962219","0.5951278","0.5935339","0.591856","0.591432","0.5899537","0.58708775","0.58708775","0.5850216","0.5849291","0.5848399","0.58404076","0.5826592","0.58204854","0.5785582","0.57833856","0.5769395","0.57557446","0.573616","0.57154024","0.5714571","0.57054263","0.5665455","0.5630818","0.560876","0.56076604","0.5567984","0.55476063","0.5537447","0.5536431","0.5501517","0.5487464","0.5485929","0.5459498","0.54548866","0.54235655","0.54126084","0.54120004","0.54031634","0.5397518","0.5395591","0.5381651","0.53722364","0.53641766","0.5362029","0.53590846","0.53590846","0.53590846","0.53493637","0.53473496","0.5337292","0.53305095","0.5313369","0.5309733","0.53060514","0.52976197","0.5295623","0.52925366","0.52856934","0.52822155","0.5266322","0.52548784","0.5248015","0.5246578","0.52464","0.5244586","0.5244586","0.52435595","0.52415204","0.52342975","0.5228086","0.5226145","0.52249813","0.5212096","0.5185612","0.51718235","0.51609355","0.5153603","0.5150247","0.51495135","0.5131622","0.51312804","0.5119022","0.5103482","0.50942427","0.50864244","0.5082575"],"string":"[\n \"0.77923155\",\n \"0.6690991\",\n \"0.6248791\",\n \"0.6209789\",\n \"0.6155369\",\n \"0.6095056\",\n \"0.60796165\",\n \"0.60738266\",\n \"0.606323\",\n \"0.60227686\",\n \"0.6020329\",\n \"0.5977967\",\n \"0.5962219\",\n \"0.5951278\",\n \"0.5935339\",\n \"0.591856\",\n \"0.591432\",\n \"0.5899537\",\n \"0.58708775\",\n \"0.58708775\",\n \"0.5850216\",\n \"0.5849291\",\n \"0.5848399\",\n \"0.58404076\",\n \"0.5826592\",\n \"0.58204854\",\n \"0.5785582\",\n \"0.57833856\",\n \"0.5769395\",\n \"0.57557446\",\n \"0.573616\",\n \"0.57154024\",\n \"0.5714571\",\n \"0.57054263\",\n \"0.5665455\",\n \"0.5630818\",\n \"0.560876\",\n \"0.56076604\",\n \"0.5567984\",\n \"0.55476063\",\n \"0.5537447\",\n \"0.5536431\",\n \"0.5501517\",\n \"0.5487464\",\n \"0.5485929\",\n \"0.5459498\",\n \"0.54548866\",\n \"0.54235655\",\n \"0.54126084\",\n \"0.54120004\",\n \"0.54031634\",\n \"0.5397518\",\n \"0.5395591\",\n \"0.5381651\",\n \"0.53722364\",\n \"0.53641766\",\n \"0.5362029\",\n \"0.53590846\",\n \"0.53590846\",\n \"0.53590846\",\n \"0.53493637\",\n \"0.53473496\",\n \"0.5337292\",\n \"0.53305095\",\n \"0.5313369\",\n \"0.5309733\",\n \"0.53060514\",\n \"0.52976197\",\n \"0.5295623\",\n \"0.52925366\",\n \"0.52856934\",\n \"0.52822155\",\n \"0.5266322\",\n \"0.52548784\",\n \"0.5248015\",\n \"0.5246578\",\n \"0.52464\",\n \"0.5244586\",\n \"0.5244586\",\n \"0.52435595\",\n \"0.52415204\",\n \"0.52342975\",\n \"0.5228086\",\n \"0.5226145\",\n \"0.52249813\",\n \"0.5212096\",\n \"0.5185612\",\n \"0.51718235\",\n \"0.51609355\",\n \"0.5153603\",\n \"0.5150247\",\n \"0.51495135\",\n \"0.5131622\",\n \"0.51312804\",\n \"0.5119022\",\n \"0.5103482\",\n \"0.50942427\",\n \"0.50864244\",\n \"0.5082575\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71455634"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":7390,"cells":{"query":{"kind":"string","value":"Update the current trigger. The GTM API does not support a partial update. Therfore, this method will send all fields expliztily set in the method arguments and those cached in the instance properties."},"document":{"kind":"string","value":"def update(self, refresh=False, parameter=None, **kwargs):\n if refresh:\n self.__init__(path=self._path, service=self.service)\n\n default_asset = {\n \"maxTimerLengthSeconds\": self._maxTimerLengthSeconds,\n \"totalTimeMinMilliseconds\": self._totalTimeMinMilliseconds,\n \"uniqueTriggerId\": self._uniqueTriggerId,\n \"verticalScrollPercentageList\": self._verticalScrollPercentageList,\n \"horizontalScrollPercentageList\": self._horizontalScrollPercentageList,\n \"containerId\": self._containerId,\n \"waitForTagsTimeout\": self._waitForTagsTimeout,\n \"accountId\": self._accountId,\n \"waitForTags\": self._waitForTags,\n \"intervalSeconds\": self._intervalSeconds,\n \"eventName\": self._eventName,\n \"visibilitySelector\": self._visibilitySelector,\n \"workspaceId\": self._workspaceId,\n \"customEventFilter\": self._customEventFilter,\n \"parentFolderId\": self._parentFolderId,\n \"continuousTimeMinMilliseconds\": self._continuousTimeMinMilliseconds,\n \"selector\": self._selector,\n \"triggerId\": self._triggerId,\n \"tagManagerUrl\": self._tagManagerUrl,\n \"fingerprint\": self._fingerprint,\n \"visiblePercentageMax\": self._visiblePercentageMax,\n \"path\": self._path,\n \"name\": self._name,\n \"visiblePercentageMin\": self._visiblePercentageMin,\n \"type\": self._type,\n \"notes\": self._notes,\n \"interval\": self._interval,\n \"filter\": self._filter,\n \"autoEventFilter\": self._autoEventFilter,\n \"limit\": self._limit,\n \"checkValidation\": self._checkValidation,\n }\n update_asset = {**default_asset, **kwargs}\n\n if parameter:\n parameter_dict = {**param_dict(self._parameter), **param_dict(parameter)}\n parameter = list(parameter_dict.values())\n else:\n parameter = self._parameter\n\n update_asset[\"parameter\"] = [x.to_obj() for x in parameter]\n\n update_asset = {k: v for k, v in update_asset.items() if v is not None}\n\n request = self.triggers_service.update(path=self.path, body=update_asset)\n response = request.execute()\n self.__init__(trigger=response, service=self.service)"},"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 update(self, *args, **kwargs):\n # callable, but does nothing by default","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs):","def update(self, *args, **kw):\n pass","def update(self, *args, **kwargs):\n if args:\n self.__update(*args)\n elif kwargs:\n self.__update(**kwargs)","def update(self, **kwargs):\n return self.parent.update_instance(self.name, kwargs)","def update(self, *args, **kwargs):\n raise NotImplementedError","def update(self, **params):\n self.parameters.update(params)","def update(self, t, timestep, cache, triggered_or_finalized):\n for field in triggered_or_finalized:\n #print name, cache[name]\n if field.params.save:\n cbc_log(20, \"Saving field %s\" %field.name)\n self._action_save(field, cache[field.name], timestep, t)\n\n if timestep%self.flush_frequency == 0:\n self._flush_data()\n self._timer.completed(\"PP: flush data\")","def update(self, *args, **kwargs) -> None:\n self.update_state(args[0])\n super().update(*args, **kwargs)","def SendUpdatedParameters(self):\n payload = { \"Arg1\": self.href }\n return self._execute('sendUpdatedParameters', payload=payload, response_object=None)","def update(self, params):","def update(self):\n self._client.patch(self)","def _update(self, count=True, forced=False):","def update(self):\n\n pass","def update(self,update_flags):\n pass","def update(self) -> None:\n self._gateway.update()","def set(self):\n if not os.path.isfile(self._trigger_file):\n with open(self._trigger_file, \"w\"):\n pass\n logger.debug(\"Set preview update trigger: %s\", self._trigger_file)","def _update(self, data: Dict[str, Any], fields_to_modify: List[str]):\n pass","def update(self, **kwargs):\n self.manager.update(self, **kwargs)","def update(self, **kwargs):\n self.manager.update(self, **kwargs)","def _update(self):\n pass","def update_params(self):\n pass","def update(self) -> None:\n ...","def update_goal(self):\n pass","def update(self, *args, **kwargs):\n if kwargs is not None:\n for key, value in kwargs.items():\n setattr(self, key, value)","def update(self):\n self.attributes = self.call('UPDATE', expect=error.OK, body=self.attributes)","def update(self) -> None:\n pass","def update(self) -> None:\n pass","def send(self, trigger, **kwargs):\n temp_data = {}\n for key, value in kwargs.iteritems():\n temp_data[key] = value\n self.evt.sendMessage(trigger, data=temp_data)","def update(self, **kwargs):\n return self._object.update(meta=kwargs)","def update(self, **options):\n pass","def update(self, es, **kwargs):\n pass","def update(self)->None:\n pass","def update(self, update_fields=None):\n instance = self.get_object() \n if not update_fields: \n update_fields=self.request.PUT.keys()\n try: \n for field in update_fields:\n update_value = self.request.PUT.get(field) # get value from PUT\n setattr(instance, field, update_value) # renew fields\n instance.save() # save updates\n except IntegrityError: # catch error\n return self.response(status='Failed to Update.') \n return self.response(\n status='Successfully Update')","def post_update(self):\n\t\tlogging.info(\"Beginning\")\n\t\toptions=dict(\n\t\t\tapi_key = self.apiKey\n\t\t)\n\t\tcounter = 0\n\t\tfor key, value in self.field.items():\n\t\t\tif value != None:\n\t\t\t\tcounter += 1\n\t\t\t\toptions[key] = value\n\t\tif counter == 0:\n\t\t\tlogging.error(\"There was nothing to update. Check the field values\")\n\t\t\treturn\n\t\turl = '{ts}update'.format(\n\t\t\tts=self.tsRUL,\n\t\t)\n\t\tlogging.debug(\"Options = \" + str(options))\n\t\ttry:\n\t\t\tresults = requests.post(url, params=options)\n\t\t\tif results.ok != True:\n\t\t\t\tlogging.error(\"The update failed\")\n\t\t\t\treturn False\n\t\texcept:\n\t\t\tlogging.error(\"There was an error trying to update the values\")\n\t\t\treturn False\n\t\tself.clear_field_values()\n\t\treturn True","def on_update(self, **kwargs):\n self.get_client()\n self.update(self, kwargs['sender'], kwargs['instance'])","def update_fields(self, request):\n message = request.message\n objects = message.model.objects\n if message.filter is not None and len(message.filter) > 0:\n objects.filter(**message.filter).update(**message.kwargs)\n\n else:\n objects.all().update(**message.kwargs)\n\n return SuccessReply()","def update(self, **kwargs):\n print(\"Updating model\")\n print(kwargs)\n for key in kwargs:\n setattr(self, key, kwargs[key])","def _update(self, force=False):\n if self.autoupdate:\n self.update(force)","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self, **kwargs):\n return self._update_data(self.put(None, data=kwargs))","def update(self, **kwargs):\n return self.manager.update(self, **kwargs)","def update(self, **kwargs):\n return self.manager.update(self, **kwargs)","def update(self, **kwargs):\n return self.manager.update(self, **kwargs)","def update(self, args):\n pass","def _update_params(self):\n pass","def update(self, *args, **kwargs):\n self.logger.update(*args, **kwargs)","def Trigger(self):\n\t\tpayload = { \"Arg1\": self.href }\n\t\treturn self._execute('trigger', payload=payload, response_object=None)","def update(self) -> None:\n pass","def update(self, *args: Any, **kwargs: Any) -> None:\n self._check_for_increment(\"update\")\n self[-1].update(*args, **kwargs)","def _update(self):\n self.all_params = {}\n self._update_experiment_params()\n self._update_preprocessing_params()\n self._update_model_params()","def update(self):\r\n pass","def fire_trigger(self, trigger):\n if not self.exists():\n return\n if trigger in self.events:\n for action in self.events[trigger]:\n action(requestor=self)","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-featured', {'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 update(self):\n return self._process('update')","def update(self, *args):\n qry = UpdateEntityQuery(self)\n self.context.add_query(qry)\n return self","def trigger_build(self, postdata):\n pass","def partial_update(self, request, guild_id, *args, **kwargs):\r\n data = request.data\r\n try:\r\n # Find the existing guild entry\r\n guild = Guild.objects.get(guild_id=guild_id)\r\n except ObjectDoesNotExist:\r\n # Entry not found - create one!\r\n guild = Guild(guild_id=guild_id)\r\n # Update kwargs\r\n for key, value in data.items():\r\n print(key, value)\r\n if value == \"reset\": value = None\r\n setattr(guild, key, value)\r\n # Submit changes\r\n guild.save()\r\n serializer = self.get_serializer(guild)\r\n return Response(serializer.data)","def create_update_trigger(self):\n self.execute(self.commands.update_function(\n self.name,\n self._equals(\n self.intersection.dest_columns,\n 'NEW',\n self.intersection.origin_columns\n ),\n self.primary_key_column\n ))\n\n self.execute(self.commands.update_trigger(\n self.triggers['UPDATE'],\n self.source.name,\n self.name\n ))","def salesforce_update(self, obj_name, obj_id, **kwargs):\n self.builtin.log(\n \"Updating {} {} with values {}\".format(obj_name, obj_id, kwargs)\n )\n obj_class = getattr(self.cumulusci.sf, obj_name)\n return obj_class.update(obj_id, kwargs)","def update(self):\n pass","def update( ):\r\n pass","def update(self, **kwargs):\n for key, val in kwargs.items():\n setattr(self, key, val)","def update(self, refresh=False, parameter=None, **kwargs):\n if parameter and not isinstance(parameter, list):\n raise ValueError(\n \"'parameter' has to be a list of :class:`GTMParameters` or 'None'.\"\n )\n\n if refresh:\n self.__init__(path=self._path, service=self.service)\n\n default_asset = {\n \"paused\": self._paused,\n \"setupTag\": self._setupTag,\n \"firingRuleId\": self._firingRuleId,\n \"teardownTag\": self._teardownTag,\n \"priority\": self._priority,\n \"parentFolderId\": self._parentFolderId,\n \"scheduleStartMs\": self._scheduleStartMs,\n \"scheduleEndMs\": self._scheduleEndMs,\n \"tagFiringOption\": self._tagFiringOption,\n \"blockingRuleId\": self._blockingRuleId,\n \"firingTriggerId\": self._firingTriggerId,\n \"name\": self._name,\n \"type\": self._type,\n \"notes\": self._notes,\n \"liveOnly\": self._liveOnly,\n \"blockingTriggerId\": self._blockingTriggerId,\n }\n update_asset = {**default_asset, **kwargs}\n\n if parameter:\n parameter_dict = {**param_dict(self._parameter), **param_dict(parameter)}\n parameter = list(parameter_dict.values())\n else:\n parameter = self._parameter\n\n update_asset[\"parameter\"] = [x.to_obj() for x in parameter]\n\n update_asset = {k: v for k, v in update_asset.items() if v is not None}\n\n request = self.tags_service.update(path=self.path, body=update_asset)\n response = request.execute()\n self.__init__(tag=response, service=self.service)","def update_goal_info(self):\n self._goal_info_cache = self._get_goal_info()","def _build_update_params(self, params):","def update_values(self, to_update):\n for key, value in kwargs.iteritems():\n self.params[key] = value\n # update the possibly dependent parameters\n self.set_filenames()","def Update(self):\r\n\r\n # does nothing\r\n pass","def update(cls) -> None:\n raise NotImplementedError","def gen_update(self, TL):\r\n pass","def beam_update(self, beams, extra):\n return extra","def __update_params(self,**kwargs):\n updatedArgSet = set(self._updateParamsArgs) & kwargs.viewkeys()\n if len(updatedArgSet) > 0:\n args = self._subDictionary(self._updateParamsArgs)\n newArgs = self._onParamsUpdate(**args)\n updatedArgs =dict()\n for k in updatedArgSet:\n try:\n updatedArgs[k] = newArgs[k]\n except:\n pass\n\n self.__dictionary.update(newArgs)\n else:\n pass","def updateParameters(self):\n\n return","def update(self, update, **kwargs):\n try:\n self.saved = False\n function_to_call = self.update_dic[update]\n function_to_call(**kwargs)\n except KeyError as e:\n pass","def update(self, **kwargs):\n self.pending_update = True\n self.update_data(**kwargs)\n self.update_selection()\n if self.context is not None and self.context.doc is not None:\n self.context.doc.add_next_tick_callback(self.update_source)","def update(self, data):\n pass","def update(self, data):\n pass"],"string":"[\n \"def update(self, *args, **kwargs):\\n # callable, but does nothing by default\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs):\",\n \"def update(self, *args, **kw):\\n pass\",\n \"def update(self, *args, **kwargs):\\n if args:\\n self.__update(*args)\\n elif kwargs:\\n self.__update(**kwargs)\",\n \"def update(self, **kwargs):\\n return self.parent.update_instance(self.name, kwargs)\",\n \"def update(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def update(self, **params):\\n self.parameters.update(params)\",\n \"def update(self, t, timestep, cache, triggered_or_finalized):\\n for field in triggered_or_finalized:\\n #print name, cache[name]\\n if field.params.save:\\n cbc_log(20, \\\"Saving field %s\\\" %field.name)\\n self._action_save(field, cache[field.name], timestep, t)\\n\\n if timestep%self.flush_frequency == 0:\\n self._flush_data()\\n self._timer.completed(\\\"PP: flush data\\\")\",\n \"def update(self, *args, **kwargs) -> None:\\n self.update_state(args[0])\\n super().update(*args, **kwargs)\",\n \"def SendUpdatedParameters(self):\\n payload = { \\\"Arg1\\\": self.href }\\n return self._execute('sendUpdatedParameters', payload=payload, response_object=None)\",\n \"def update(self, params):\",\n \"def update(self):\\n self._client.patch(self)\",\n \"def _update(self, count=True, forced=False):\",\n \"def update(self):\\n\\n pass\",\n \"def update(self,update_flags):\\n pass\",\n \"def update(self) -> None:\\n self._gateway.update()\",\n \"def set(self):\\n if not os.path.isfile(self._trigger_file):\\n with open(self._trigger_file, \\\"w\\\"):\\n pass\\n logger.debug(\\\"Set preview update trigger: %s\\\", self._trigger_file)\",\n \"def _update(self, data: Dict[str, Any], fields_to_modify: List[str]):\\n pass\",\n \"def update(self, **kwargs):\\n self.manager.update(self, **kwargs)\",\n \"def update(self, **kwargs):\\n self.manager.update(self, **kwargs)\",\n \"def _update(self):\\n pass\",\n \"def update_params(self):\\n pass\",\n \"def update(self) -> None:\\n ...\",\n \"def update_goal(self):\\n pass\",\n \"def update(self, *args, **kwargs):\\n if kwargs is not None:\\n for key, value in kwargs.items():\\n setattr(self, key, value)\",\n \"def update(self):\\n self.attributes = self.call('UPDATE', expect=error.OK, body=self.attributes)\",\n \"def update(self) -> None:\\n pass\",\n \"def update(self) -> None:\\n pass\",\n \"def send(self, trigger, **kwargs):\\n temp_data = {}\\n for key, value in kwargs.iteritems():\\n temp_data[key] = value\\n self.evt.sendMessage(trigger, data=temp_data)\",\n \"def update(self, **kwargs):\\n return self._object.update(meta=kwargs)\",\n \"def update(self, **options):\\n pass\",\n \"def update(self, es, **kwargs):\\n pass\",\n \"def update(self)->None:\\n pass\",\n \"def update(self, update_fields=None):\\n instance = self.get_object() \\n if not update_fields: \\n update_fields=self.request.PUT.keys()\\n try: \\n for field in update_fields:\\n update_value = self.request.PUT.get(field) # get value from PUT\\n setattr(instance, field, update_value) # renew fields\\n instance.save() # save updates\\n except IntegrityError: # catch error\\n return self.response(status='Failed to Update.') \\n return self.response(\\n status='Successfully Update')\",\n \"def post_update(self):\\n\\t\\tlogging.info(\\\"Beginning\\\")\\n\\t\\toptions=dict(\\n\\t\\t\\tapi_key = self.apiKey\\n\\t\\t)\\n\\t\\tcounter = 0\\n\\t\\tfor key, value in self.field.items():\\n\\t\\t\\tif value != None:\\n\\t\\t\\t\\tcounter += 1\\n\\t\\t\\t\\toptions[key] = value\\n\\t\\tif counter == 0:\\n\\t\\t\\tlogging.error(\\\"There was nothing to update. Check the field values\\\")\\n\\t\\t\\treturn\\n\\t\\turl = '{ts}update'.format(\\n\\t\\t\\tts=self.tsRUL,\\n\\t\\t)\\n\\t\\tlogging.debug(\\\"Options = \\\" + str(options))\\n\\t\\ttry:\\n\\t\\t\\tresults = requests.post(url, params=options)\\n\\t\\t\\tif results.ok != True:\\n\\t\\t\\t\\tlogging.error(\\\"The update failed\\\")\\n\\t\\t\\t\\treturn False\\n\\t\\texcept:\\n\\t\\t\\tlogging.error(\\\"There was an error trying to update the values\\\")\\n\\t\\t\\treturn False\\n\\t\\tself.clear_field_values()\\n\\t\\treturn True\",\n \"def on_update(self, **kwargs):\\n self.get_client()\\n self.update(self, kwargs['sender'], kwargs['instance'])\",\n \"def update_fields(self, request):\\n message = request.message\\n objects = message.model.objects\\n if message.filter is not None and len(message.filter) > 0:\\n objects.filter(**message.filter).update(**message.kwargs)\\n\\n else:\\n objects.all().update(**message.kwargs)\\n\\n return SuccessReply()\",\n \"def update(self, **kwargs):\\n print(\\\"Updating model\\\")\\n print(kwargs)\\n for key in kwargs:\\n setattr(self, key, kwargs[key])\",\n \"def _update(self, force=False):\\n if self.autoupdate:\\n self.update(force)\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self, **kwargs):\\n return self._update_data(self.put(None, data=kwargs))\",\n \"def update(self, **kwargs):\\n return self.manager.update(self, **kwargs)\",\n \"def update(self, **kwargs):\\n return self.manager.update(self, **kwargs)\",\n \"def update(self, **kwargs):\\n return self.manager.update(self, **kwargs)\",\n \"def update(self, args):\\n pass\",\n \"def _update_params(self):\\n pass\",\n \"def update(self, *args, **kwargs):\\n self.logger.update(*args, **kwargs)\",\n \"def Trigger(self):\\n\\t\\tpayload = { \\\"Arg1\\\": self.href }\\n\\t\\treturn self._execute('trigger', payload=payload, response_object=None)\",\n \"def update(self) -> None:\\n pass\",\n \"def update(self, *args: Any, **kwargs: Any) -> None:\\n self._check_for_increment(\\\"update\\\")\\n self[-1].update(*args, **kwargs)\",\n \"def _update(self):\\n self.all_params = {}\\n self._update_experiment_params()\\n self._update_preprocessing_params()\\n self._update_model_params()\",\n \"def update(self):\\r\\n pass\",\n \"def fire_trigger(self, trigger):\\n if not self.exists():\\n return\\n if trigger in self.events:\\n for action in self.events[trigger]:\\n action(requestor=self)\",\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-featured', {'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 update(self):\\n return self._process('update')\",\n \"def update(self, *args):\\n qry = UpdateEntityQuery(self)\\n self.context.add_query(qry)\\n return self\",\n \"def trigger_build(self, postdata):\\n pass\",\n \"def partial_update(self, request, guild_id, *args, **kwargs):\\r\\n data = request.data\\r\\n try:\\r\\n # Find the existing guild entry\\r\\n guild = Guild.objects.get(guild_id=guild_id)\\r\\n except ObjectDoesNotExist:\\r\\n # Entry not found - create one!\\r\\n guild = Guild(guild_id=guild_id)\\r\\n # Update kwargs\\r\\n for key, value in data.items():\\r\\n print(key, value)\\r\\n if value == \\\"reset\\\": value = None\\r\\n setattr(guild, key, value)\\r\\n # Submit changes\\r\\n guild.save()\\r\\n serializer = self.get_serializer(guild)\\r\\n return Response(serializer.data)\",\n \"def create_update_trigger(self):\\n self.execute(self.commands.update_function(\\n self.name,\\n self._equals(\\n self.intersection.dest_columns,\\n 'NEW',\\n self.intersection.origin_columns\\n ),\\n self.primary_key_column\\n ))\\n\\n self.execute(self.commands.update_trigger(\\n self.triggers['UPDATE'],\\n self.source.name,\\n self.name\\n ))\",\n \"def salesforce_update(self, obj_name, obj_id, **kwargs):\\n self.builtin.log(\\n \\\"Updating {} {} with values {}\\\".format(obj_name, obj_id, kwargs)\\n )\\n obj_class = getattr(self.cumulusci.sf, obj_name)\\n return obj_class.update(obj_id, kwargs)\",\n \"def update(self):\\n pass\",\n \"def update( ):\\r\\n pass\",\n \"def update(self, **kwargs):\\n for key, val in kwargs.items():\\n setattr(self, key, val)\",\n \"def update(self, refresh=False, parameter=None, **kwargs):\\n if parameter and not isinstance(parameter, list):\\n raise ValueError(\\n \\\"'parameter' has to be a list of :class:`GTMParameters` or 'None'.\\\"\\n )\\n\\n if refresh:\\n self.__init__(path=self._path, service=self.service)\\n\\n default_asset = {\\n \\\"paused\\\": self._paused,\\n \\\"setupTag\\\": self._setupTag,\\n \\\"firingRuleId\\\": self._firingRuleId,\\n \\\"teardownTag\\\": self._teardownTag,\\n \\\"priority\\\": self._priority,\\n \\\"parentFolderId\\\": self._parentFolderId,\\n \\\"scheduleStartMs\\\": self._scheduleStartMs,\\n \\\"scheduleEndMs\\\": self._scheduleEndMs,\\n \\\"tagFiringOption\\\": self._tagFiringOption,\\n \\\"blockingRuleId\\\": self._blockingRuleId,\\n \\\"firingTriggerId\\\": self._firingTriggerId,\\n \\\"name\\\": self._name,\\n \\\"type\\\": self._type,\\n \\\"notes\\\": self._notes,\\n \\\"liveOnly\\\": self._liveOnly,\\n \\\"blockingTriggerId\\\": self._blockingTriggerId,\\n }\\n update_asset = {**default_asset, **kwargs}\\n\\n if parameter:\\n parameter_dict = {**param_dict(self._parameter), **param_dict(parameter)}\\n parameter = list(parameter_dict.values())\\n else:\\n parameter = self._parameter\\n\\n update_asset[\\\"parameter\\\"] = [x.to_obj() for x in parameter]\\n\\n update_asset = {k: v for k, v in update_asset.items() if v is not None}\\n\\n request = self.tags_service.update(path=self.path, body=update_asset)\\n response = request.execute()\\n self.__init__(tag=response, service=self.service)\",\n \"def update_goal_info(self):\\n self._goal_info_cache = self._get_goal_info()\",\n \"def _build_update_params(self, params):\",\n \"def update_values(self, to_update):\\n for key, value in kwargs.iteritems():\\n self.params[key] = value\\n # update the possibly dependent parameters\\n self.set_filenames()\",\n \"def Update(self):\\r\\n\\r\\n # does nothing\\r\\n pass\",\n \"def update(cls) -> None:\\n raise NotImplementedError\",\n \"def gen_update(self, TL):\\r\\n pass\",\n \"def beam_update(self, beams, extra):\\n return extra\",\n \"def __update_params(self,**kwargs):\\n updatedArgSet = set(self._updateParamsArgs) & kwargs.viewkeys()\\n if len(updatedArgSet) > 0:\\n args = self._subDictionary(self._updateParamsArgs)\\n newArgs = self._onParamsUpdate(**args)\\n updatedArgs =dict()\\n for k in updatedArgSet:\\n try:\\n updatedArgs[k] = newArgs[k]\\n except:\\n pass\\n\\n self.__dictionary.update(newArgs)\\n else:\\n pass\",\n \"def updateParameters(self):\\n\\n return\",\n \"def update(self, update, **kwargs):\\n try:\\n self.saved = False\\n function_to_call = self.update_dic[update]\\n function_to_call(**kwargs)\\n except KeyError as e:\\n pass\",\n \"def update(self, **kwargs):\\n self.pending_update = True\\n self.update_data(**kwargs)\\n self.update_selection()\\n if self.context is not None and self.context.doc is not None:\\n self.context.doc.add_next_tick_callback(self.update_source)\",\n \"def update(self, data):\\n pass\",\n \"def update(self, data):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5962123","0.5947622","0.5947622","0.5947622","0.59135634","0.59135634","0.59135634","0.59135634","0.59135634","0.59135634","0.5901567","0.5882499","0.5750089","0.56001323","0.55886126","0.5582611","0.5573218","0.5543781","0.5498977","0.54955","0.54674727","0.5463991","0.54621005","0.5460992","0.54535913","0.5450029","0.5422599","0.5419838","0.5419838","0.54126394","0.5406283","0.54036415","0.53973114","0.53803176","0.5374489","0.537222","0.537222","0.5365947","0.53652555","0.5358669","0.53584826","0.5354586","0.53543305","0.534246","0.5336804","0.5327476","0.5324454","0.5313821","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.5308361","0.53043085","0.52973455","0.52973455","0.52973455","0.5254326","0.52519715","0.5236873","0.5231428","0.5225212","0.5219121","0.5218469","0.52175814","0.5188678","0.51811504","0.5172458","0.51674587","0.5159252","0.5156413","0.5146719","0.51419723","0.51411456","0.5116667","0.5109338","0.5101641","0.51013285","0.51007056","0.5095034","0.50850695","0.50815475","0.5076299","0.5073628","0.50720465","0.5068525","0.50659895","0.5056036","0.504933","0.504933"],"string":"[\n \"0.5962123\",\n \"0.5947622\",\n \"0.5947622\",\n \"0.5947622\",\n \"0.59135634\",\n \"0.59135634\",\n \"0.59135634\",\n \"0.59135634\",\n \"0.59135634\",\n \"0.59135634\",\n \"0.5901567\",\n \"0.5882499\",\n \"0.5750089\",\n \"0.56001323\",\n \"0.55886126\",\n \"0.5582611\",\n \"0.5573218\",\n \"0.5543781\",\n \"0.5498977\",\n \"0.54955\",\n \"0.54674727\",\n \"0.5463991\",\n \"0.54621005\",\n \"0.5460992\",\n \"0.54535913\",\n \"0.5450029\",\n \"0.5422599\",\n \"0.5419838\",\n \"0.5419838\",\n \"0.54126394\",\n \"0.5406283\",\n \"0.54036415\",\n \"0.53973114\",\n \"0.53803176\",\n \"0.5374489\",\n \"0.537222\",\n \"0.537222\",\n \"0.5365947\",\n \"0.53652555\",\n \"0.5358669\",\n \"0.53584826\",\n \"0.5354586\",\n \"0.53543305\",\n \"0.534246\",\n \"0.5336804\",\n \"0.5327476\",\n \"0.5324454\",\n \"0.5313821\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.5308361\",\n \"0.53043085\",\n \"0.52973455\",\n \"0.52973455\",\n \"0.52973455\",\n \"0.5254326\",\n \"0.52519715\",\n \"0.5236873\",\n \"0.5231428\",\n \"0.5225212\",\n \"0.5219121\",\n \"0.5218469\",\n \"0.52175814\",\n \"0.5188678\",\n \"0.51811504\",\n \"0.5172458\",\n \"0.51674587\",\n \"0.5159252\",\n \"0.5156413\",\n \"0.5146719\",\n \"0.51419723\",\n \"0.51411456\",\n \"0.5116667\",\n \"0.5109338\",\n \"0.5101641\",\n \"0.51013285\",\n \"0.51007056\",\n \"0.5095034\",\n \"0.50850695\",\n \"0.50815475\",\n \"0.5076299\",\n \"0.5073628\",\n \"0.50720465\",\n \"0.5068525\",\n \"0.50659895\",\n \"0.5056036\",\n \"0.504933\",\n \"0.504933\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56299794"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":7391,"cells":{"query":{"kind":"string","value":"Delete the current trigger."},"document":{"kind":"string","value":"def delete(self):\n request = self.triggers_service.delete(path=self._path)\n request.execute()"},"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 _delTrigger(self, message: IRCMessage) -> IRCResponse:\n triggerName = message.parameterList[1]\n if triggerName in self.storage:\n del self.storage[triggerName]\n return IRCResponse(f\"Trigger {triggerName} deleted!\", message.replyTo)\n else:\n return IRCResponse(f\"No trigger named {triggerName} exists.\", message.replyTo)","def delete_trigger(self, trigger_id):\n self._delete(path=\"triggers/{}\".format(trigger_id))","def create_delete_trigger(self):\n self.execute(self.commands.delete_function(\n dest_table=self.name,\n pk_col=self.primary_key_column\n ))\n\n self.execute(self.commands.delete_trigger(\n self.triggers['DELETE'],\n self.source.name,\n self.name\n ))","def clear(self):\n if os.path.isfile(self._trigger_file):\n os.remove(self._trigger_file)\n logger.debug(\"Removed preview update trigger: %s\", self._trigger_file)","def delete(self):\n\t\tdel self.scheduler.find(self)\n\t\tdel self","def delete(self, trigger_id):\n try:\n self._client.delete(self._full_path(trigger_id))\n return False\n except InvalidJSONError:\n return True","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n self.current_revision.delete()","def deleteOrDelay(self):\n self.delete()","def delete(self):\n self._instance.delete()\n self._instance = None\n self._data_defs = []","def __macroDelete(self):\n self.activeWindow().macroDelete()","def test_remove_trigger(self) -> None:\n trigger = auraxium.Trigger(auraxium.event.Death, name='on_death')\n self.client.add_trigger(trigger)\n self.assertEqual(len(self.client.triggers), 1)\n self.client.remove_trigger('on_death')\n self.assertEqual(len(self.client.triggers), 0)\n with self.assertRaises(KeyError):\n self.client.remove_trigger('does_not_exist')","def delete(self):\n # type: () -> BoundAction\n return self._client.delete(self)","def drop_trigger(self, trig):\n self.vr_trig_queue.put((trig,'done'))","def delete(self):\n ...","def delete(self):\n self._client.delete(self)","def delete(self):\n with self.locked():\n self.path.delete()","def delete(self):\n with self.locked():\n self.path.delete()","def delete(self) -> None:\n self.pop()","def delete():","def delete(self):\n\n raise NotImplementedError('Must be implemented by subclasses')","def delete(self):\n os.system(\"rm \"+self._name)","def delete(self):\n\t\t#self.log.info(\"Deleting file {}\".format(self._filepath))\n\t\tos.remove(self._filepath)","def delete(self):\r\n delete_tracks(self.project, [self])","def delete_at_index(self, idx):\n del self.timeseries[idx]\n del self.freq[idx]\n del self.ch_name[idx]\n del self.units[idx]\n\n if self.trigger_idx == idx:\n LGR.warning(\"Removing trigger channel - are you sure you are doing\" \"the right thing?\")\n self.trigger_idx = 0","def delete(self):\n # exit contains our clean up code\n self.exit()\n GenericAnimatedProp.GenericAnimatedProp.delete(self)","def delete_template(self):\n try:\n os.remove(self.path)\n except Exception:\n pass","def delete(self):\n return self.parent.delete_instance(self.name)","def trigger_delete(cls, instance):\n es_client.delete(instance.blog.index_name(), 'blog_post_index', instance.id)","def delete(self):\n if not self.is_deleted:\n self.is_deleted = True\n self.save()","def delete(self):\n self.oxdb.execute(DELETE, self.variable_name, commit=True)\n self._exists = None","def delete(self):\n\n raise NotImplementedError()","def delete(self):\n pdbox._args.get(\"dryrun\") or shutil.rmtree(self.path)\n pdbox.info(\"Deleted %s/\" % self.path)","def __del__(self):\n print(f\"{self.fullname()} deleted from database.\")","def delete(self):\n del self.shx.atoms[self.index]","def delete(self):\n self.manager.delete(self.name)","def delete(self):\n self.manager.delete(self.name)","def delete(self):\n self.request().delete()","def delete(self):\n return self._delete","def delete(self):\r\n self.domain.delete_item(self)","def delete(self):\n pdbox._args.get(\"dryrun\") or os.remove(self.path)\n pdbox.info(\"Deleted %s\" % self.path)","def delete_trigger(name: str, engine: Engine, table: str, schema: str = None):\n schema = schema or 'public'\n\n engine.execute(f'DROP TRIGGER IF EXISTS {name} ON {schema}.{table}')","def delete(self) -> None:\n shutil.rmtree(self.path)","def delete(self):\n\t\tself.eventStatus = 0\n\t\tself.save()\n\n\t\t# DEBUG\n\t\tcontext = {\n\t\t\t'call_stack': ''.join(traceback.format_stack()),\n\t\t\t'event': self,\n\t\t\t'server_addr': settings.SERVER_ADDRESS,\n\t\t}\n\t\tbody = render_to_string('MHLCallGroups/Scheduler/email_delete_event.txt', context)\n\t\tmail_admins(_('Event Deletion Attempt!'), body)","def hdel(self):\n return self.delete()","def removeTrigger(self, trigger):\r\n for k, t in self.literalTriggers.iteritems():\r\n if t.title == trigger:\r\n del self.literalTriggers[k]\r\n return False\r\n else:\r\n for k, t in self.triggers.iteritems():\r\n if t.title == trigger:\r\n del self.triggers[k]\r\n return True\r\n return False","def delete(self):\n self.model.remove_agents(self)","def delete(self, *args, **kwargs):\n pass","def delete(self, *args, **kwargs):\n pass","def delete():\n click.echo('delete was called.')","def delete(self):\n self.manager.delete(self)","def delete_document(self):\n pass","def ClearRecordsForTrigger(self):\n\t\tpayload = { \"Arg1\": self.href }\n\t\treturn self._execute('clearRecordsForTrigger', payload=payload, response_object=None)","def delete(self):\n self.vera.delete_scene(self)","def delete(self):\n DATABASE_CONNECTION.delete(self.__class__.__name__, self.id)","def delete_command():\n global selected_tuple\n backend.delete(selected_tuple[0])","def force_delete(self):\n self.manager.force_delete(self)","def force_delete(self):\n self.manager.force_delete(self)","def __delete__(self):\n pass","async def delete(self):\n return await self.set_message(text='')","def delete(self, downstream = None):\n # emit delete message\n self.deleteSignal.emit(self)","def delete( self ):\n if os.path.exists(self.filename):\n os.remove(self.filename)","def delete(self):\n self.graph._del(handle=self.handle)","def delete(self, filename):\n pass","def delete(self):\n\n try:\n remove(self.file)\n except OSError:\n pass","def unsetTrigger(self):\n return _libsbml.Event_unsetTrigger(self)","def delete(self):\n raise NotImplementedError","def delete(self):\n if self.is_running:\n raise errors.ChalmersError(\"Can not remove running program (must be stopped)\")\n\n if path.isfile(self.definition_filename):\n os.unlink(self.definition_filename)\n\n if path.isfile(self.state_filename):\n os.unlink(self.state_filename)","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete_word(event):\n get_by_name(\"backward-kill-word\").call(event)","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def delete(self):\n self.data = None","def remove(self):\r\n\t\tself._delete()","def delete(self):\n self.method = \"DELETE\"\n self.send()","def __del__(self) -> None:\n self.delete()","def delete(self):\n self.package = None"],"string":"[\n \"def _delTrigger(self, message: IRCMessage) -> IRCResponse:\\n triggerName = message.parameterList[1]\\n if triggerName in self.storage:\\n del self.storage[triggerName]\\n return IRCResponse(f\\\"Trigger {triggerName} deleted!\\\", message.replyTo)\\n else:\\n return IRCResponse(f\\\"No trigger named {triggerName} exists.\\\", message.replyTo)\",\n \"def delete_trigger(self, trigger_id):\\n self._delete(path=\\\"triggers/{}\\\".format(trigger_id))\",\n \"def create_delete_trigger(self):\\n self.execute(self.commands.delete_function(\\n dest_table=self.name,\\n pk_col=self.primary_key_column\\n ))\\n\\n self.execute(self.commands.delete_trigger(\\n self.triggers['DELETE'],\\n self.source.name,\\n self.name\\n ))\",\n \"def clear(self):\\n if os.path.isfile(self._trigger_file):\\n os.remove(self._trigger_file)\\n logger.debug(\\\"Removed preview update trigger: %s\\\", self._trigger_file)\",\n \"def delete(self):\\n\\t\\tdel self.scheduler.find(self)\\n\\t\\tdel self\",\n \"def delete(self, trigger_id):\\n try:\\n self._client.delete(self._full_path(trigger_id))\\n return False\\n except InvalidJSONError:\\n return True\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n self.current_revision.delete()\",\n \"def deleteOrDelay(self):\\n self.delete()\",\n \"def delete(self):\\n self._instance.delete()\\n self._instance = None\\n self._data_defs = []\",\n \"def __macroDelete(self):\\n self.activeWindow().macroDelete()\",\n \"def test_remove_trigger(self) -> None:\\n trigger = auraxium.Trigger(auraxium.event.Death, name='on_death')\\n self.client.add_trigger(trigger)\\n self.assertEqual(len(self.client.triggers), 1)\\n self.client.remove_trigger('on_death')\\n self.assertEqual(len(self.client.triggers), 0)\\n with self.assertRaises(KeyError):\\n self.client.remove_trigger('does_not_exist')\",\n \"def delete(self):\\n # type: () -> BoundAction\\n return self._client.delete(self)\",\n \"def drop_trigger(self, trig):\\n self.vr_trig_queue.put((trig,'done'))\",\n \"def delete(self):\\n ...\",\n \"def delete(self):\\n self._client.delete(self)\",\n \"def delete(self):\\n with self.locked():\\n self.path.delete()\",\n \"def delete(self):\\n with self.locked():\\n self.path.delete()\",\n \"def delete(self) -> None:\\n self.pop()\",\n \"def delete():\",\n \"def delete(self):\\n\\n raise NotImplementedError('Must be implemented by subclasses')\",\n \"def delete(self):\\n os.system(\\\"rm \\\"+self._name)\",\n \"def delete(self):\\n\\t\\t#self.log.info(\\\"Deleting file {}\\\".format(self._filepath))\\n\\t\\tos.remove(self._filepath)\",\n \"def delete(self):\\r\\n delete_tracks(self.project, [self])\",\n \"def delete_at_index(self, idx):\\n del self.timeseries[idx]\\n del self.freq[idx]\\n del self.ch_name[idx]\\n del self.units[idx]\\n\\n if self.trigger_idx == idx:\\n LGR.warning(\\\"Removing trigger channel - are you sure you are doing\\\" \\\"the right thing?\\\")\\n self.trigger_idx = 0\",\n \"def delete(self):\\n # exit contains our clean up code\\n self.exit()\\n GenericAnimatedProp.GenericAnimatedProp.delete(self)\",\n \"def delete_template(self):\\n try:\\n os.remove(self.path)\\n except Exception:\\n pass\",\n \"def delete(self):\\n return self.parent.delete_instance(self.name)\",\n \"def trigger_delete(cls, instance):\\n es_client.delete(instance.blog.index_name(), 'blog_post_index', instance.id)\",\n \"def delete(self):\\n if not self.is_deleted:\\n self.is_deleted = True\\n self.save()\",\n \"def delete(self):\\n self.oxdb.execute(DELETE, self.variable_name, commit=True)\\n self._exists = None\",\n \"def delete(self):\\n\\n raise NotImplementedError()\",\n \"def delete(self):\\n pdbox._args.get(\\\"dryrun\\\") or shutil.rmtree(self.path)\\n pdbox.info(\\\"Deleted %s/\\\" % self.path)\",\n \"def __del__(self):\\n print(f\\\"{self.fullname()} deleted from database.\\\")\",\n \"def delete(self):\\n del self.shx.atoms[self.index]\",\n \"def delete(self):\\n self.manager.delete(self.name)\",\n \"def delete(self):\\n self.manager.delete(self.name)\",\n \"def delete(self):\\n self.request().delete()\",\n \"def delete(self):\\n return self._delete\",\n \"def delete(self):\\r\\n self.domain.delete_item(self)\",\n \"def delete(self):\\n pdbox._args.get(\\\"dryrun\\\") or os.remove(self.path)\\n pdbox.info(\\\"Deleted %s\\\" % self.path)\",\n \"def delete_trigger(name: str, engine: Engine, table: str, schema: str = None):\\n schema = schema or 'public'\\n\\n engine.execute(f'DROP TRIGGER IF EXISTS {name} ON {schema}.{table}')\",\n \"def delete(self) -> None:\\n shutil.rmtree(self.path)\",\n \"def delete(self):\\n\\t\\tself.eventStatus = 0\\n\\t\\tself.save()\\n\\n\\t\\t# DEBUG\\n\\t\\tcontext = {\\n\\t\\t\\t'call_stack': ''.join(traceback.format_stack()),\\n\\t\\t\\t'event': self,\\n\\t\\t\\t'server_addr': settings.SERVER_ADDRESS,\\n\\t\\t}\\n\\t\\tbody = render_to_string('MHLCallGroups/Scheduler/email_delete_event.txt', context)\\n\\t\\tmail_admins(_('Event Deletion Attempt!'), body)\",\n \"def hdel(self):\\n return self.delete()\",\n \"def removeTrigger(self, trigger):\\r\\n for k, t in self.literalTriggers.iteritems():\\r\\n if t.title == trigger:\\r\\n del self.literalTriggers[k]\\r\\n return False\\r\\n else:\\r\\n for k, t in self.triggers.iteritems():\\r\\n if t.title == trigger:\\r\\n del self.triggers[k]\\r\\n return True\\r\\n return False\",\n \"def delete(self):\\n self.model.remove_agents(self)\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete():\\n click.echo('delete was called.')\",\n \"def delete(self):\\n self.manager.delete(self)\",\n \"def delete_document(self):\\n pass\",\n \"def ClearRecordsForTrigger(self):\\n\\t\\tpayload = { \\\"Arg1\\\": self.href }\\n\\t\\treturn self._execute('clearRecordsForTrigger', payload=payload, response_object=None)\",\n \"def delete(self):\\n self.vera.delete_scene(self)\",\n \"def delete(self):\\n DATABASE_CONNECTION.delete(self.__class__.__name__, self.id)\",\n \"def delete_command():\\n global selected_tuple\\n backend.delete(selected_tuple[0])\",\n \"def force_delete(self):\\n self.manager.force_delete(self)\",\n \"def force_delete(self):\\n self.manager.force_delete(self)\",\n \"def __delete__(self):\\n pass\",\n \"async def delete(self):\\n return await self.set_message(text='')\",\n \"def delete(self, downstream = None):\\n # emit delete message\\n self.deleteSignal.emit(self)\",\n \"def delete( self ):\\n if os.path.exists(self.filename):\\n os.remove(self.filename)\",\n \"def delete(self):\\n self.graph._del(handle=self.handle)\",\n \"def delete(self, filename):\\n pass\",\n \"def delete(self):\\n\\n try:\\n remove(self.file)\\n except OSError:\\n pass\",\n \"def unsetTrigger(self):\\n return _libsbml.Event_unsetTrigger(self)\",\n \"def delete(self):\\n raise NotImplementedError\",\n \"def delete(self):\\n if self.is_running:\\n raise errors.ChalmersError(\\\"Can not remove running program (must be stopped)\\\")\\n\\n if path.isfile(self.definition_filename):\\n os.unlink(self.definition_filename)\\n\\n if path.isfile(self.state_filename):\\n os.unlink(self.state_filename)\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete_word(event):\\n get_by_name(\\\"backward-kill-word\\\").call(event)\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def delete(self):\\n self.data = None\",\n \"def remove(self):\\r\\n\\t\\tself._delete()\",\n \"def delete(self):\\n self.method = \\\"DELETE\\\"\\n self.send()\",\n \"def __del__(self) -> None:\\n self.delete()\",\n \"def delete(self):\\n self.package = None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7167729","0.70552254","0.6779274","0.6583904","0.655758","0.64790803","0.6461914","0.6461914","0.6461914","0.6461914","0.645271","0.64262265","0.62824124","0.6266517","0.62515134","0.62503153","0.62478745","0.62462974","0.6191452","0.61563873","0.61563873","0.61363184","0.6109357","0.6104194","0.6091601","0.60879666","0.60828376","0.60796404","0.6074667","0.60692894","0.60397273","0.60386515","0.60212356","0.6013759","0.60083455","0.6007559","0.5990807","0.597058","0.59644616","0.59644616","0.59618175","0.5959596","0.5958881","0.5958856","0.5954542","0.59512925","0.59508365","0.59355956","0.59319544","0.5926145","0.5915153","0.5915153","0.59148014","0.59021616","0.58863074","0.5885904","0.5882063","0.58790785","0.58767354","0.58728176","0.58728176","0.58724385","0.5866614","0.5865847","0.5863907","0.5863506","0.5861332","0.58588994","0.58587253","0.5855503","0.58466923","0.583655","0.583655","0.583655","0.583655","0.583655","0.583655","0.583655","0.583655","0.583655","0.582966","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.58283526","0.5818831","0.5817396","0.5812874","0.5807403","0.5800533"],"string":"[\n \"0.7167729\",\n \"0.70552254\",\n \"0.6779274\",\n \"0.6583904\",\n \"0.655758\",\n \"0.64790803\",\n \"0.6461914\",\n \"0.6461914\",\n \"0.6461914\",\n \"0.6461914\",\n \"0.645271\",\n \"0.64262265\",\n \"0.62824124\",\n \"0.6266517\",\n \"0.62515134\",\n \"0.62503153\",\n \"0.62478745\",\n \"0.62462974\",\n \"0.6191452\",\n \"0.61563873\",\n \"0.61563873\",\n \"0.61363184\",\n \"0.6109357\",\n \"0.6104194\",\n \"0.6091601\",\n \"0.60879666\",\n \"0.60828376\",\n \"0.60796404\",\n \"0.6074667\",\n \"0.60692894\",\n \"0.60397273\",\n \"0.60386515\",\n \"0.60212356\",\n \"0.6013759\",\n \"0.60083455\",\n \"0.6007559\",\n \"0.5990807\",\n \"0.597058\",\n \"0.59644616\",\n \"0.59644616\",\n \"0.59618175\",\n \"0.5959596\",\n \"0.5958881\",\n \"0.5958856\",\n \"0.5954542\",\n \"0.59512925\",\n \"0.59508365\",\n \"0.59355956\",\n \"0.59319544\",\n \"0.5926145\",\n \"0.5915153\",\n \"0.5915153\",\n \"0.59148014\",\n \"0.59021616\",\n \"0.58863074\",\n \"0.5885904\",\n \"0.5882063\",\n \"0.58790785\",\n \"0.58767354\",\n \"0.58728176\",\n \"0.58728176\",\n \"0.58724385\",\n \"0.5866614\",\n \"0.5865847\",\n \"0.5863907\",\n \"0.5863506\",\n \"0.5861332\",\n \"0.58588994\",\n \"0.58587253\",\n \"0.5855503\",\n \"0.58466923\",\n \"0.583655\",\n \"0.583655\",\n \"0.583655\",\n \"0.583655\",\n \"0.583655\",\n \"0.583655\",\n \"0.583655\",\n \"0.583655\",\n \"0.583655\",\n \"0.582966\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.58283526\",\n \"0.5818831\",\n \"0.5817396\",\n \"0.5812874\",\n \"0.5807403\",\n \"0.5800533\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8082834"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":7392,"cells":{"query":{"kind":"string","value":"Create and return a D0 > hh' Selection object."},"document":{"kind":"string","value":"def makeD2hhAsymm(name,\n config,\n KPIDK_string,\n PiPIDK_string,\n Mass_low_string,\n Mass_high_string,\n CombPIDK_string,\n DecayDescriptor,\n inputSel,\n useTOS,\n Hlt1TOS,\n Hlt2TOS\n ) :\n\n def makeTISTOS( name, _input, _hlttos ) :\n from Configurables import TisTosParticleTagger\n _tisTosFilter = TisTosParticleTagger( name + \"Tagger\" )\n _tisTosFilter.TisTosSpecs = _hlttos\n return Selection( name\n , Algorithm = _tisTosFilter\n , RequiredSelections = [ _input ]\n ) \n\n _Kcuts1 = \"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\" % locals()['config']\n _KcutsPIDK = KPIDK_string % locals()['config']\n _Kcuts2 = \" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\" % locals()['config']\n _Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\n _Picuts1 = \"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\" % locals()['config']\n _PicutsPIDK = PiPIDK_string % locals()['config']\n _Picuts2 = \" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\" % locals()['config']\n _Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\n _dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\n\n _massLow = Mass_low_string % locals()['config']\n _massHigh = Mass_high_string % locals()['config']\n _combCuts1 = \"(APT > %(D0Pt)s* MeV)\" \\\n \"& (AHASCHILD( PT > %(DaugPtMax)s* MeV ) )\" \\\n \"& (ADOCA(1,2)< %(D0DOCA)s* mm)\" \\\n \"& (AP > %(D0P)s* MeV)\" % locals()['config']\n _combCutsPIDK = CombPIDK_string % locals()['config']\n _combCuts = _combCuts1 + _combCutsPIDK + _massLow + _massHigh\n\n _motherCuts = \"(VFASPF(VCHI2PDOF) < %(D0VtxChi2Ndof)s)\" \\\n \"& (BPVVDCHI2 > %(D0FDChi2)s)\" \\\n \"& (BPVLTIME() > %(D0Tau)s)\" \\\n \"& (BPVDIRA > %(D0BPVDira)s)\" % locals()['config']\n\n _D0 = CombineParticles( DecayDescriptor = DecayDescriptor,\n MotherCut = _motherCuts,\n CombinationCut = _combCuts,\n DaughtersCuts = _dauCuts)\n\n _sel = Selection ( name+'Sel',\n Algorithm = _D0,\n RequiredSelections = inputSel )\n\n if not useTOS:\n return _sel\n\n _selD2hhHlt1TOS = makeTISTOS( name + \"D2hhHlt1TOS\"\n , _sel\n , Hlt1TOS\n )\n _selD2hhHlt2TOS = makeTISTOS( name + \"D2hhHlt2TOS\"\n , _selD2hhHlt1TOS\n , Hlt2TOS\n )\n \n return _selD2hhHlt2TOS"},"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 from_selection(cls):\n guid = compas_rhino.select_point()\n return cls.from_guid(guid)","def get_slider():\n return dcc.RangeSlider(\n id='hours',\n value=[0, 23],\n min=0,\n max=23,\n marks={i: str(i) for i in range(0, 24, 3)}\n )","def from_selection(cls):\n guid = compas_rhino.select_mesh()\n return cls.from_guid(guid)","def rangeselector_time():\n return {\n \"bgcolor\": \"rgb(35, 149, 86)\",\n \"activecolor\": \"rgb(25, 108, 62)\",\n \"buttons\": [\n {\"count\": 12, \"label\": \"12h\", \"step\": \"hour\", \"stepmode\": \"backward\"},\n {\"count\": 24, \"label\": \"24h\", \"step\": \"hour\", \"stepmode\": \"backward\"},\n {\"count\": 48, \"label\": \"48h\", \"step\": \"hour\", \"stepmode\": \"backward\"},\n {\"count\": 3, \"label\": \"3d\", \"step\": \"day\", \"stepmode\": \"backward\"},\n {\"count\": 7, \"label\": \"7d\", \"step\": \"day\", \"stepmode\": \"backward\"},\n {\"step\": \"all\"},\n ],\n }","def selection(self):\n if not self._selection:\n return None\n \n year, month = self._date.year, self._date.month\n return self.datetime(year, month, int(self._selection[0]))","def create(cls, selection):\n\t\t\n\t\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })","def from_selection(\n class_,\n selection,\n item_class=None,\n ):\n import abjad\n pitch_segment = abjad.PitchSegment.from_selection(selection)\n return class_(\n pitch_segment,\n item_class=item_class,\n )","def select_hours(self, lhours):\n sel = []\n for i in range(self.dataset.shape[0]):\n stime = time.localtime(np.int32(self.dataset[i][2]))\n hour = stime[3]\n for ih in lhours:\n ihour, fhour = ih\n if ihour <= hour < fhour:\n sel.append(i)\n data = STData(self.wpath, self.city, self.application)\n data.dataset = self.dataset[sel]\n return data","def _select_by_range(self, disc_low, disc_high):\n sqlstmt = \"SELECT h FROM %s WHERE d>=? and d<=?\" % self.VIEW\n pickup = self.cursor.execute(sqlstmt, (disc_low, disc_high,))\n return [h[0] for h in pickup]","def _select_by_range(self, disc_low, disc_high):\n sqlstmt = \"SELECT h FROM %s WHERE d>=? and d<=?\" % self.VIEW\n pickup = self.cursor.execute(sqlstmt, (-disc_high, -disc_low))\n return [h[0] for h in pickup]","def selection(self):\r\n if not self._selection:\r\n print(\"not working\")\r\n return None\r\n\r\n year, month = self._date.year, self._date.month\r\n if len(str(month))==1:\r\n month = \"0{}\".format(month)\r\n return (\"{}{}{}\".format(year, month, self._selection[0]), \r\n \"{} / {} / {}\".format(year, month, self._selection[0]))","def get_selection(self, selection_name, format=None):","def makeSelection(self, selection=\"\"):\n\n\t\tif selection == \"\":\n\t\t\tprint \"usage: makeSelection(selection)\"\n\n\t\tsel_string = self.parseMacros(selection)\n\n\t\t# --- split by \";\" --- #\n\t\ttmp = []\n\t\tcols = []\n\t\tcols = sel_string.split(\";\")\n\t\tfor col in cols:\n\t\t\tinverse = False\n\t\t\tif col == \"\":\n\t\t\t\tcontinue\n\n\t\t\ttmp = string.split(col, \"=\")\n\t\t\tif \"!\" in tmp[0]:\n\t\t\t\tinverse = True\n\n\t\t\tif \"resi\" in tmp[0]:\n\t\t\t\tself.parseResI(tmp[1])\n\t\t\t\tself.invresi = inverse\n\t\t\telif \"resn\" in tmp[0]:\n\t\t\t\tself.parseResN(tmp[1])\n\t\t\t\tself.invresn = inverse\n\t\t\telif \"name\" in tmp[0]:\n\t\t\t\tself.parseAtom(tmp[1])\n\t\t\t\tself.invatom = inverse\n\t\t\telif \"element\" in tmp[0]:\n\t\t\t\tself.parseElement(tmp[1])\n\t\t\t\tself.invelement = inverse\t\n\t\t\telif \"chain\" in tmp[0]:\n\t\t\t\tself.parseChain(tmp[1])\n\t\t\t\tself.invchain = inverse\n\t\t\telif \"type\" in tmp[0]:\n\t\t\t\tself.parseType(tmp[1])\n\t\t\t\tself.invtype = inverse\n\t\t\telif \"cat\" in tmp[0]:\n\t\t\t\tself.parseCat(tmp[1])\n\t\t\t\tself.invcat = inverse\n\t\t\telif \"atomid\" in tmp[0]:\n\t\t\t\tself.parseAtomid(tmp[1])\n\t\t\t\tself.invatomid = inverse\n\t\t\telif \"BB\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O \")\n\t\t\t\tself.invatom = False\n\t\t\telif \"CEN\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O , CB \")\n\t\t\t\tself.invatom = False\n\t\t\telif \"SC\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O \")\n\t\t\t\tself.invatom = True\n\t\t\telif \"HET\" in tmp[0]:\n\t\t\t\tself.parseType(\"HETATM\")\n\t\t\t\tself.invtype = inverse\n\t\t\telse:\n\t\t\t\tprint \"unrecognized selector: \",tmp[0]\n\t\t\t\tsys.exit()","def get_h0(self, t):\n return self.h0","def get_selection():\n\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\n sel_len = len(selected)\n result = SelectionContainer()\n\n for _x in range(0, sel_len):\n\n shape_type = selected[_x].ShapeType\n\n if shape_type == 'Vertex':\n result.vertices.append(selected[_x])\n\n elif shape_type == 'Edge':\n\n if 'Line' in str(selected[_x].Curve):\n result.lines.append(selected[_x])\n else:\n result.curves.append(selected[_x])","def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\n #\n ## check existing selection\n #\n sel = self._selection ( sel_tag )\n if sel : return sel \n\n #\n ## adjust a bit the arguments\n if not kwargs.has_key('Preambulo') :\n kwargs ['Preambulo' ] = self['Preambulo']\n\n if not kwargs.has_key( 'ParticleCombiners' ) :\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \n \n # \n ## use \"simple-selection\"\n #\n from PhysSelPython.Wrappers import SimpleSelection\n sel = SimpleSelection (\n sel_name ,\n algotype ,\n inputs , \n *args ,\n **kwargs )\n # \n return self._add_selection( sel_tag , sel )","def build_selection_spec(client_factory, name):\r\n sel_spec = client_factory.create('ns0:SelectionSpec')\r\n sel_spec.name = name\r\n return sel_spec","def getSect(self, h):\n coordtrasp=self.coord.T\n lefttomin=self.coord[1][:self.min+1]\n # left point\n lpnt = self.firstPointAfter_h(lefttomin[::-1], h)\n # find index of left point\n l_pnt = self.min - lpnt\n # find left intersection\n l_intersect = self.intersection(coordtrasp[l_pnt], coordtrasp[l_pnt+1], h)\n # right point\n rpnt = self.firstPointAfter_h(self.coord[1][self.min:], h)\n # find index of right point\n r_pnt = self.min + rpnt\n # find right intersection\n r_intersect = self.intersection(coordtrasp[r_pnt], coordtrasp[r_pnt-1], h)\n # make new section geometries\n sez = coordtrasp[l_pnt+1:r_pnt]\n # Add left intersection on the top\n sez=np.insert(sez, [0,], l_intersect,axis=0)\n # Add rightht intersection on the bottom\n sez=np.append(sez,[r_intersect],axis=0)\n return sez","def createSelector(self,type='select',speed=2.0):\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector.hide()\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def createSelector2(self,type='select',speed=2.0):\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector2.hide()\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def cdd_Hrepresentation(self):\n return cdd_Hrepresentation(self._cdd_type, \n [i for i in self.inequalities()],\n [e for e in self.equation_generator()] )","def _add_selection ( self , nick , sel ) :\n if not self.__selections_.has_key ( self.name() ) :\n self.__selections_[ self.name() ] = {} \n \n if self.__selections_[ self.name()].has_key( nick ) :\n raise AttributeError , \"Selection '%s'already exists \" % nick\n \n self.__selections_[ self.name() ][ nick ] = sel\n \n return sel","def shortened_selective(G, H):\n if G == 0 or H == 0:\n return Game(0)\n else:\n left_1 = {shortened_selective(G_L, H) for G_L in G._left}\n left_2 = {shortened_selective(G, H_L) for H_L in H._left}\n left_3 = {shortened_selective(G_L, H_L) for G_L in G._left for H_L in H._left}\n right_1 = {shortened_selective(G_R, H) for G_R in G._right}\n right_2 = {shortened_selective(G, H_R) for H_R in H._right}\n right_3 = {shortened_selective(G_R, H_R) for G_R in G._right for H_R in H._right}\n return Game(left_1 | left_2 | left_3, right_1 | right_2 | right_3)","def __hour(self):\n return _VirtualColumn(\n df_name=self.thisptr[\"df_name_\"],\n operator=\"hour\",\n operand1=self,\n operand2=None\n )","def add_selector(self, listing):\n # We will be able to select X-frames and its boundaries\n # will be stored in the given list\n\n def onselect(xmin, xmax):\n# indmin, indmax = np.searchsorted(x, (xmin, xmax))\n# indmax = min(len(x)-1, indmax)\n indmin = xmin\n indmax = xmax\n onselect.listing.append([indmin, indmax])\n print (onselect.listing)\n \n onselect.listing = listing\n \n # set useblit True on gtkagg for enhanced performance\n ax = self.axes\n span = SpanSelector(ax, onselect, 'horizontal', useblit=True,\n rectprops=dict(alpha=0.5, facecolor='red') )\n \n self.widget_list.append(span)","def data_selection(data, columnX=\"time\", columnY=\"forceX\", ylim=None):\n\n fig = plt.figure(figsize=(8, 6))\n ax = fig.add_subplot(111)\n if ylim is not None:\n ax.set_ylim(ylim[0], ylim[1])\n x = data[columnX]\n y = data[columnY]\n ax.plot(x, y, '-')\n\n fig.suptitle(\"Press any key to confirm selection and close this window\", fontsize=14, fontweight='bold')\n ax.set_title(\"Select data by dragging the mouse\")\n\n def onselect(xmin, xmax):\n \"\"\"\n Sub-function to assign the minimum and maximum of the range and plot the selection\"\n\n Args:\n xmin (int): minimum index of selection\n xmax (int): maximum index of selection\n \"\"\"\n global indmin\n global indmax\n global span\n\n try:\n span.remove()\n fig.canvas.draw()\n except:\n pass\n\n indmin, indmax = np.searchsorted(x, (xmin, xmax))\n indmax = min(len(x) - 1, indmax)\n ax.axvspan(x.values[int(indmin)], x.values[int(indmax)], facecolor=\"red\", alpha=0.5)\n fig.canvas.draw()\n\n # set useblit True on gtkagg for enhanced performance\n span = SpanSelector(ax, onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red'))\n mng = plt.get_current_fig_manager()\n mng.window.showMaximized()\n plt.show()\n\n while True:\n wait = plt.waitforbuttonpress(timeout=60)\n if wait:\n plt.close('all')\n break\n else:\n pass\n\n idCol = column_indexer(data)\n mask = (data[columnX] >= data.iloc[indmin, idCol[columnX]]) & \\\n (data[columnX] <= data.iloc[indmax, idCol[columnX]])\n subData = data.loc[mask, :]\n\n return subData","def hour(self) -> Index:\n warnings.warn(\n \"`hour` will return int32 index instead of int 64 index in 4.0.0.\",\n FutureWarning,\n )\n return Index(self.to_series().dt.hour)","def care_color_HH(selection):\n acids = \"{} and (resn ASP or resn ASH or resn GLU or resn GLH)\".format(selection)\n bases = \"{} and (resn HIS or resn HIE or resn HID or resn HIP or resn ARG \\\n or resn LYS or resn LYN)\".format(selection)\n polars = \"{} and (resn CYS or resn CYX or resn GLN or resn ASN or resn SER \\\n or resn TYR or resn THR)\".format(selection)\n nonpolars = \"{} and (resn GLY or resn ALA or resn LEU or resn ILE or resn PHE \\\n or resn TRP or resn MET or resn PRO or resn VAL)\".format(selection)\n cmd.color(\"firebrick\", acids)\n cmd.color(\"deepteal\", bases)\n cmd.color(\"tv_orange\", polars)\n cmd.color(\"smudge\", nonpolars)\n util.cnc(selection)","def _get_range(self):\n return tuple((0, m, 1) for m in self.level_shapes[0])","def _getAsSelection(self):\n return self._asSelection","def get_gold_selection(self, pointer):\n raise NotImplementedError","def get_gti_from_hdu(gtihdu):\n gtitable = gtihdu.data\n\n colnames = [col.name for col in gtitable.columns]\n # Default: NuSTAR: START, STOP. Otherwise, try RXTE: Start, Stop\n if \"START\" in colnames:\n startstr, stopstr = \"START\", \"STOP\"\n else:\n startstr, stopstr = \"Start\", \"Stop\"\n\n gtistart = np.array(gtitable.field(startstr), dtype=np.longdouble)\n gtistop = np.array(gtitable.field(stopstr), dtype=np.longdouble)\n gti_list = np.vstack((gtistart, gtistop)).T\n\n return gti_list","def rangeselector_date():\n return {\n \"bgcolor\": \"rgb(35, 149, 86)\",\n \"activecolor\": \"rgb(25, 108, 62)\",\n \"buttons\": [\n {\"count\": 7, \"label\": \"1w\", \"step\": \"day\", \"stepmode\": \"backward\"},\n {\"count\": 14, \"label\": \"2w\", \"step\": \"day\", \"stepmode\": \"backward\"},\n {\"count\": 1, \"label\": \"1m\", \"step\": \"month\", \"stepmode\": \"backward\"},\n {\"count\": 3, \"label\": \"3m\", \"step\": \"month\", \"stepmode\": \"backward\"},\n {\"step\": \"all\"},\n ],\n }","def select_time(new_cube, lower, upper):\n\n sliced_cube = new_cube.extract(iris.Constraint(year=lambda y: lower<=y<=upper))\n\n return sliced_cube","def select(cursor, q, expire_after=None):\n if expire_after:\n query = \"\"\"SELECT h.* FROM hasil h\n JOIN pencarian p ON (p.id=h.query_id)\n WHERE p.query=:query and \n CAST( \n (JULIANDAY('now', 'localtime') - JULIANDAY(p.timestamp)) \n AS INTEGER) <= :expire_after\"\"\"\n \n rows = cursor.execute(query, {'query': q,\n 'expire_after': expire_after})\n return HasilCollections(rows)\n raise NotImplementedError","def start(self):\n return _uhd_swig.range_t_start(self)","def __init__(self,\n h=0.01):\n super().__init__(1, 100000000,\n 1, 1,\n 5, 10,\n 0, -1, h)","def horde_start(self, observation):","def __call__(self) -> abjad.Selection:\n if (self._repetition_chance == 0.0\n or random.random() > self._repetition_chance):\n if not self._is_first_window or self._process_on_first_call:\n if self._mode == 'out':\n self._remove_element()\n else:\n self._add_element()\n elif not self._include_empty_measures and self._mode == 'in':\n self._add_element()\n self._mask_to_selection()\n return self.current_window","def get_selection(\n cls,\n selections: list[str],\n title: str = \"\",\n subtitle: str = \"\",\n ) -> int:\n menu = cls.make_selection_menu(\n selections=selections,\n title=title,\n subtitle=subtitle,\n show_exit_item=False,\n )\n return cast(int, menu.show())","def blankUpdateRange(dayHour):\n return { 'position': dayHour, 'updateHistory': [dayHour], 'width': Predictor.rangeWidth }","def roi_hdu_from_sel(\n sel_image: np.ndarray,\n color_ix: int,\n eye_name: str,\n instrument: str = \"MCAM\",\n sel_fn: str = None,\n) -> fits.PrimaryHDU:\n roi_array = select_roi_by_ix(sel_image, color_ix)\n color_name = roi_color_ix_to_color_name(color_ix, instrument)\n merspect_metadata = {\"EYE\": eye_name, \"SOURCEFN\": Path(sel_fn).name}\n roi_hdu = make_roi_hdu(roi_array, color_name, merspect_metadata)\n roi_hdu.name = color_name + \" \" + eye_name\n return roi_hdu","def _select_single(self, disc):\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)","def make_selection_menu(\n cls,\n selections: list[str],\n title: str = \"\",\n subtitle: str = \"\",\n *,\n show_exit_item: bool = False,\n ) -> CursesMenu:\n menu = cls(title=title, subtitle=subtitle, show_exit_item=show_exit_item)\n from cursesmenu.items.selection_item import SelectionItem\n\n for index, selection in enumerate(selections):\n menu.items.append(\n SelectionItem(text=selection, index=index, should_exit=True),\n )\n return menu","def extract_H_ranges(Work: dict) -> str:\n work_H_rows = Work[\"libE_info\"][\"H_rows\"]\n if len(work_H_rows) == 1:\n return str(work_H_rows[0])\n else:\n # From https://stackoverflow.com/a/30336492\n ranges = []\n for diff, group in groupby(enumerate(work_H_rows.tolist()), lambda x: x[0] - x[1]):\n group = list(map(itemgetter(1), group))\n if len(group) > 1:\n ranges.append(str(group[0]) + \"-\" + str(group[-1]))\n else:\n ranges.append(str(group[0]))\n return \"_\".join(ranges)","def select_bounds(ds, bounds):\n \n xs = slice(bounds[0][0], bounds[1][0])\n ys = slice(bounds[1][1], bounds[0][1])\n # select over x and y axis\n return ds.sel(x=xs, y=ys)","def get_geometry(self, selection_name):","def generate_24hrs():\n\n hrs = []\n\n for i in xrange(1, 25):\n hrs.append([i, 0])\n\n return hrs","def _getHyperslabSlices(dsetshape, select):\n\n if select is None:\n # Default: return entire dataset\n return tuple(slice(0, extent) for extent in dsetshape)\n\n if not select.startswith('['):\n msg = \"Bad Request: selection query missing start bracket\"\n raise HTTPError(400, reason=msg)\n if not select.endswith(']'):\n msg = \"Bad Request: selection query missing end bracket\"\n raise HTTPError(400, reason=msg)\n\n # strip brackets\n select = select[1:-1]\n\n select_array = select.split(',')\n if len(select_array) > len(dsetshape):\n msg = \"Bad Request: number of selected dimensions exceeds the rank of the dataset\"\n raise HTTPError(400, reason=msg)\n\n slices = []\n for dim, dim_slice in enumerate(select_array):\n extent = dsetshape[dim]\n\n # default slice values\n start = 0\n stop = extent\n step = 1\n if dim_slice.find(':') < 0:\n # just a number - return slice(start, start + 1, 1) for this dimension\n try:\n start = int(dim_slice)\n except ValueError:\n msg = \"Bad Request: invalid selection parameter (can't convert to int) for dimension: \" + str(dim)\n raise HTTPError(400, reason=msg)\n stop = start + 1\n elif dim_slice == ':':\n # select everything (default)\n pass\n else:\n fields = dim_slice.split(\":\")\n if len(fields) > 3:\n msg = \"Bad Request: Too many ':' seperators for dimension: \" + str(dim)\n raise HTTPError(400, reason=msg)\n try:\n if fields[0]:\n start = int(fields[0])\n if fields[1]:\n stop = int(fields[1])\n if len(fields) > 2 and fields[2]:\n step = int(fields[2])\n except ValueError:\n msg = \"Bad Request: invalid selection parameter (can't convert to int) for dimension: \" + str(dim)\n raise HTTPError(400, reason=msg)\n\n if start < 0 or start > extent:\n msg = \"Bad Request: Invalid selection start parameter for dimension: \" + str(dim)\n raise HTTPError(400, reason=msg)\n if stop > extent:\n msg = \"Bad Request: Invalid selection stop parameter for dimension: \" + str(dim)\n raise HTTPError(400, reason=msg)\n if step <= 0:\n msg = \"Bad Request: invalid selection step parameter for dimension: \" + str(dim)\n raise HTTPError(400, reason=msg)\n slices.append(slice(start, stop, step))\n\n return tuple(slices)","def __init__(self):\n self.minh = []\n self.maxh = []","def create_selector_bcg(self, bcg_sd, bcg_time):\n bcg_nr = self.time_to_number(bcg_time)\n bcg = self.filter_line.iloc[0:bcg_nr].mean()\n std = self.filter_line.iloc[0:bcg_nr].std()\n ind = [True if value > bcg+bcg_sd *\n std else False for value in self.filter_line]\n ind2 = ind[1:]\n ind2.append(False)\n index = [i for i in range(0, len(ind)) if ind[i] != ind2[i]]\n\n self.starts = [index[i] for i in range(len(index)) if i % 2 == 0]\n self.ends = [index[i] for i in range(len(index)) if i % 2 != 0]\n\n self.create_on_off()","def _select_all(self):\n sqlstmt = \"SELECT d, h FROM %s\" % self.VIEW\n return [(-d, h) for (d, h) in self.cursor.execute(sqlstmt)]","def get_selection_first_coord(sel, name=\"(sel)\"):\n\n #print \"--> selection %(name)s: %(sel)s\" % vars()\n cmd.select(name, sel)\n try:\n return numpy.array(cmd.get_model(name).atom[0].coord)\n except IndexError:\n print \"--> empty selection: %(sel)s\" % vars()\n raise","def define_range():\n\n def_range = {'lt': [0.0, 24.0],\n 'lon': [0.0, 360.0],\n 'angle': [0.0, 2.0 * np.pi]}\n\n return def_range","def _generateTimeSelector(self, dParams, sPreamble, sPostamble):\n\n if WuiDispatcherBase.ksParamEffectiveDate in dParams:\n tsEffective = dParams[WuiDispatcherBase.ksParamEffectiveDate]\n del dParams[WuiDispatcherBase.ksParamEffectiveDate]\n else:\n tsEffective = ''\n\n # Forget about page No when changing a period\n if WuiDispatcherBase.ksParamPageNo in dParams:\n del dParams[WuiDispatcherBase.ksParamPageNo]\n\n sHtmlTimeSelector = '<form name=\"TimeForm\" method=\"GET\">\\n'\n sHtmlTimeSelector += sPreamble;\n sHtmlTimeSelector += '\\n <select name=\"%s\" onchange=\"window.location=' % WuiDispatcherBase.ksParamEffectiveDate\n sHtmlTimeSelector += '\\'?%s&%s=\\' + ' % (webutils.encodeUrlParams(dParams), WuiDispatcherBase.ksParamEffectiveDate)\n sHtmlTimeSelector += 'this.options[this.selectedIndex].value;\" title=\"Effective date\">\\n'\n\n aoWayBackPoints = [\n ('+0000-00-00 00:00:00.00', 'Now', ' title=\"Present Day. Present Time.\"'), # lain :)\n\n ('-0000-00-00 01:00:00.00', '1 hour ago', ''),\n ('-0000-00-00 02:00:00.00', '2 hours ago', ''),\n ('-0000-00-00 03:00:00.00', '3 hours ago', ''),\n\n ('-0000-00-01 00:00:00.00', '1 day ago', ''),\n ('-0000-00-02 00:00:00.00', '2 days ago', ''),\n ('-0000-00-03 00:00:00.00', '3 days ago', ''),\n\n ('-0000-00-07 00:00:00.00', '1 week ago', ''),\n ('-0000-00-14 00:00:00.00', '2 weeks ago', ''),\n ('-0000-00-21 00:00:00.00', '3 weeks ago', ''),\n\n ('-0000-01-00 00:00:00.00', '1 month ago', ''),\n ('-0000-02-00 00:00:00.00', '2 months ago', ''),\n ('-0000-03-00 00:00:00.00', '3 months ago', ''),\n ('-0000-04-00 00:00:00.00', '4 months ago', ''),\n ('-0000-05-00 00:00:00.00', '5 months ago', ''),\n ('-0000-06-00 00:00:00.00', 'Half a year ago', ''),\n\n ('-0001-00-00 00:00:00.00', '1 year ago', ''),\n ]\n fSelected = False;\n for sTimestamp, sWayBackPointCaption, sExtraAttrs in aoWayBackPoints:\n if sTimestamp == tsEffective:\n fSelected = True;\n sHtmlTimeSelector += ' <option value=\"%s\"%s%s>%s</option>\\n' \\\n % (webutils.quoteUrl(sTimestamp),\n ' selected=\"selected\"' if sTimestamp == tsEffective else '',\n sExtraAttrs, sWayBackPointCaption)\n if not fSelected and tsEffective != '':\n sHtmlTimeSelector += ' <option value=\"%s\" selected>%s</option>\\n' \\\n % (webutils.quoteUrl(tsEffective), tsEffective)\n\n sHtmlTimeSelector += ' </select>\\n';\n sHtmlTimeSelector += sPostamble;\n sHtmlTimeSelector += '\\n</form>\\n'\n\n return sHtmlTimeSelector","def _select_single(self, disc):\n sqlstmt = \"SELECT h FROM %s WHERE d=?\" % self.VIEW\n pickup = self.cursor.execute(sqlstmt, (disc,))\n picked = pickup.fetchone()\n if picked is not None:\n # picked = (h,)\n return picked[0]\n else:\n raise KeyError(str(disc))","def Clone(self) -> \"itkIsoDataThresholdCalculatorHDUS_Pointer\":\n return _itkIsoDataThresholdCalculatorPython.itkIsoDataThresholdCalculatorHDUS_Clone(self)","def __init__(self, id, interval, times=0, q=0, s=0):\n self.id = id\n self.interval = interval\n self.times = times\n self.q = q\n self.s = s","def start(self):\n return _uhd_swig.meta_range_t_start(self)","def get_range(g,h,d): # g: graph; h: head node; d: dependent node\n addresses = sorted(g.nodes.keys())\n h_index = addresses.index(h)\n d_index = addresses.index(d)\n sign = cmp(d_index,h_index)\n return addresses[h_index:d_index+sign:sign]","def from_harte_interval(cls, harte_interval_string):\n if isinstance(harte_interval_string, int):\n harte_interval_string = str(harte_interval_string)\n harte_interval_string = harte_interval_string.strip(' ')\n return cls(find_item(HARTE_INTERVALS, harte_interval_string))","def from_hff(cls, hff_data, name=None, args=None):\n _assert_or_raise(hff_data, h5py.Group)\n obj = cls(new_obj=False)\n if u'xmin' in hff_data:\n obj.xmin = hff_data[u'xmin'][()]\n if u'xmax' in hff_data:\n obj.xmax = hff_data[u'xmax'][()]\n if u'ymin' in hff_data:\n obj.ymin = hff_data[u'ymin'][()]\n if u'ymax' in hff_data:\n obj.ymax = hff_data[u'ymax'][()]\n if u'zmin' in hff_data:\n obj.zmin = hff_data[u'zmin'][()]\n if u'zmax' in hff_data:\n obj.zmax = hff_data[u'zmax'][()]\n return obj","def select(self):\n pass","def select(self):\n pass","def viewport_selection():\n sel = oMa.MGlobal.getActiveSelectionList()\n\n for i in range(sel.length()):\n m_obj = sel.getDependNode(i)\n yield m_obj","def get_empty_obj(ch_temp):\n return ChData(None, time_type.TimeType(), ch_temp)","def Clone(self) -> \"itkIsoDataThresholdCalculatorHDSS_Pointer\":\n return _itkIsoDataThresholdCalculatorPython.itkIsoDataThresholdCalculatorHDSS_Clone(self)","def h(self, x, u, t):\n \n x, z = self._split_states( x )\n \n y = self.plant.h( x, u, t)\n \n return y","def _selection ( self, nick ) :\n \n if not self.__selections_.has_key ( self.name() ) :\n self.__selections_[ self.name() ] = {} \n \n return self.__selections_[ self.name() ].get( nick , None )","def hxlselect():\n run_script(hxlselect_main)","def convex_hull(self):\n return self._geomgen(capi.geom_convex_hull)","def New(*args, **kargs):\n obj = itkIsoDataThresholdCalculatorHDUC.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def New(*args, **kargs):\n obj = itkIsoDataThresholdCalculatorHDSS.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def __init__(self):\n self.intervalList = [] # intervalList is a table with \"start\" and \"end\" columns indicating the start and end of each interval","def select(self):\n\n return self.p[0], self.p[1]","def makeDstarPartial( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )","def raster_time_select_list(self, selected_field, selected_list_state, selected_list_id, is_readonly, select_list_initial_msg):\n\n raster_time_name_value_dic = {'name': ['2', '4'], 'value': ['2', '4']}\n return make_select_list_using_dictionary(raster_time_name_value_dic, selected_field, selected_list_state, selected_list_id, is_readonly, select_list_initial_msg)","def makeDstar2D0Pi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )","def select(self):\r\n pass","def selectaround(document, selection=None):\n selection = selection or document.selection\n default_chars = ['{', '[', '(', '<', '\\'', '\"']\n candidates = []\n for char in default_chars:\n candidate = selectaround_char(document, char, selection)\n if candidate != None:\n candidates.append(candidate)\n if candidates:\n # Select smallest enclosing candidate\n return min(candidates, key=avg_interval_length)","def getHourColumn(self): \n return self.hourcol","def get_selection(self, pointer, answer_sheet, sel_none_of_above):\n def answer_parsing(answer_str):\n selections = answer_str.split(\", \")\n try:\n selections = [int(sel) for sel in selections]\n except:\n return None\n else:\n assert len(selections)\n if sel_none_of_above in selections:\n assert len(selections) == 1 # mutual exclusive \"none of the above\"\n return selections\n\n answer = input(\"Please enter the option id(s) delimited by comma ', ': \")\n selections = answer_parsing(answer)\n while selections is None:\n answer = input(\"Please enter the option id(s) delimited by comma ', ': \")\n selections = answer_parsing(answer)\n\n return selections","def select(self):\n return","def get_buffer_selection (buffer):\n bounds = buffer.get_selection_bounds()\n if len(bounds) == 0:\n return \"\"\n else:\n return buffer.get_slice(*bounds)","def parse_range(option):\n return {\"range\": timedelta(days=option)}","def horde_init(self, horde_info= {}):","def get_header_table(self , dt, ds = '' , all_ds = '', length = ''):\n index_low = self.unique_dates[ds]['indices'][dt]['low']\n #index_up = self.unique_dates[best_ds]['indices'][dt]['up'] \n hd = self.data[ds]['header_table'][index_low:index_low+length] \n hd['duplicates'] = all_ds \n \n return hd","def __getSelectionFilter(self):\n \n selectionPairs = []\n selectionPairs.append(('field','field'))\n selectionPairs.append(('spw','spw'))\n selectionPairs.append(('polarization','correlation'))\n selectionPairs.append(('baseline','antenna'))\n selectionPairs.append(('time','timerange'))\n selectionPairs.append(('scan','scan'))\n selectionPairs.append(('uvdist','uvrange'))\n selectionPairs.append(('scanintent','intent'))\n selectionPairs.append(('observation','observation'))\n return self.__generateFilter(selectionPairs)","def __chanSelection(self, spwsel):\n \n # Split to get each spw in a list\n if spwsel.__contains__(','):\n spwlist = spwsel.split(',') \n else:\n spwlist = spwsel.split(';')\n \n spwid=[]\n chanlist=[]\n # Split to create two lists, one with channels, the other with spwIDs\n for isel in spwlist:\n # Get tail, colon and head\n (s, c, ch) = isel.rpartition(\":\")\n # Remove any blanks\n s = s.strip(' ')\n c = c.strip(' ')\n ch = ch.strip(' ')\n # If no tail, there was no colon to split. In this case, add the spwID\n if s == \"\":\n spwid.append(ch)\n chanlist.append('')\n else:\n spwid.append(s)\n chanlist.append(ch)\n \n # Create a dictionary\n seldict = {}\n for ns in xrange(len(spwid)):\n sel = {}\n sel['spw'] = spwid[ns]\n sel['channels'] = chanlist[ns]\n seldict[ns] = sel\n\n\n return seldict","def __init__(self, time=0, uni=None, dmx=None):\n self.time = time\n self.dmx = {}\n if uni and dmx:\n self.dmx[uni] = dmx","def add_hic_interval_subparser(subparsers):\n parser = subparsers.add_parser(\"hic-interval\",\n help=\"HiFive Binning Function: Create a tabular interaction file containing data from a HiFive HiC project. Data are a genomic-interval format (chr1 start1 stop1 chr2 start2 stop2).\")\n parser.add_argument(\"-c\", \"--chromosome\", dest=\"chrom\", default=None, required=True, type=str,\n help=\"The chromosome from which to pull interaction data from.\")\n parser.add_argument(\"--chromosome2\", dest=\"chrom2\", default=None, required=False, type=str,\n help=\"The second chromosome from which to pull interaction data from if pulling trans data.\")\n parser.add_argument(\"-s\", \"--start\", dest=\"start\", default=None, required=False, type=int,\n help=\"The start coordinate of the pulled region to return. (None indicates the first valid bin on the chromosome) [default %(default)s]\")\n parser.add_argument(\"-e\", \"--stop\", dest=\"stop\", default=None, required=False, type=int,\n help=\"The stop coordinate of the pulled region to return. (None indicates the last valid bin on the chromosome) [default %(default)s]\")\n parser.add_argument(\"--start2\", dest=\"start2\", default=None, required=False, type=int,\n help=\"The start coordinate of the second chromosome pulled region to return. (None indicates the first valid bin on the chromosome) [default %(default)s]\")\n parser.add_argument(\"--stop2\", dest=\"stop2\", default=None, required=False, type=int,\n help=\"The stop coordinate of the second chromosome pulled region to return. (None indicates the last valid bin on the chromosome) [default %(default)s]\")\n parser.add_argument(\"-b\", \"--binsize\", dest=\"binsize\", default=10000, type=int,\n help=\"The size of bins, in base pairs, to group data into. [default: %(default)s]\")\n parser.add_argument(\"-m\", \"--max-distance\", dest=\"maxdist\", default=None, type=int,\n help=\"The maximum interaction distance to return (None indicates no maximum). [default: %(default)s]\")\n parser.add_argument(\"-d\", \"--data-type\", dest=\"datatype\", default=\"fend\",\n help=\"Which corrections (if any) to apply to counts. [default: %(default)s]\",\n choices=[\"raw\", \"fend\", \"distance\", \"enrichment\", \"expected\"])\n parser.add_argument(\"-M\", \"--matrix\", dest=\"matrix\", default=False, action=\"store_true\",\n help=\"Store output as a tab-separated matrix of values.\")\n parser.add_argument(\"-y\", \"--dynamically-bin\", dest=\"dynamic\", default=False, action=\"store_true\",\n help=\"Dynamically bin heatmap.\")\n parser.add_argument(\"-x\", \"--expansion-binsize\", dest=\"expbinsize\", default=10000, type=int,\n help=\"The size of bins, in base pairs, to group data into for expanding under-populated bins. [default: %(default)s]\")\n parser.add_argument(\"-f\", \"--minobservations\", dest=\"minobs\", default=20, type=int,\n help=\"The minimum number of observed reads in a bin for it to be considered valid. [default: %(default)s]\")\n parser.add_argument(\"-a\", \"--search-distance\", dest=\"search\", default=0, type=int,\n help=\"The furthest distance from the bin minpoint to expand bounds. If set to zero, there is no limit on expansion distance. [default: %(default)s]\")\n parser.add_argument(\"-v\", \"--remove-failed\", dest=\"remove\", default=False, action=\"store_true\",\n help=\"If a non-zero 'search-distance' is given, it is possible for a bin not to meet the 'minobservations' criteria before stopping looking. If this occurs and 'remove-failed' is set, the observed and expected values for that bin are zero.\")\n parser.add_argument(\"-i\", \"--image-file\", dest=\"image\", default=None, type=str,\n help=\"Save the data as an image to this file.\")\n parser.add_argument(\"-p\", \"--pdf\", dest=\"pdf\", default=False, action=\"store_true\",\n help=\"Format the image in PDF format. [default: %(default)s]\")\n parser.add_argument(\"-r\", \"--rotate\", dest=\"rotate\", default=False, action=\"store_true\",\n help=\"Rotate the plot 45 degrees (cis binned only). [default: %(default)s]\")\n parser.add_argument(\"-t\", \"--ticks\", dest=\"ticks\", default=False, action=\"store_true\",\n help=\"Add tick marks and labels to the plot (pdf format and binned only). [default: %(default)s]\")\n parser.add_argument(\"-l\", \"--legend\", dest=\"legend\", default=False, action=\"store_true\",\n help=\"Add color scale to the plot (pdf format only). [default: %(default)s]\")\n parser.add_argument(\"-k\", \"--keyword\", dest=\"keywords\", default=[], type=str, action='append',\n help=\"Additional keyword arguments to pass to plotting function.\")\n add_silent_argument(parser)\n parser.add_argument(dest=\"project\", type=str,\n help=\"The name of a HiFive HiC project file to pull data from.\")\n parser.add_argument(dest=\"output\", type=str,\n help=\"The name of the file to write HiC interval to.\")\n return","def create_ham(self):\n from tcc.interaction import HAM_SPINLESS_RI_CORE\n return HAM_SPINLESS_RI_CORE(self)","def create_ham(self):\n from tcc.interaction import HAM_SPINLESS_RI_CORE\n return HAM_SPINLESS_RI_CORE(self)","def generate_access_time_plot_from_range(id_range, val):\n segments = []\n points = []\n\n for i in id_range:\n if isinstance(i, list):\n endpoints = [(i[0], val), (i[1], val)]\n segments.append(endpoints)\n else:\n points.append((i, val))\n return segments, points","def selective(G, H):\n left_1 = {selective(G_L, H) for G_L in G._left}\n left_2 = {selective(G, H_L) for H_L in H._left}\n left_3 = {selective(G_L, H_L) for G_L in G._left for H_L in H._left}\n right_1 = {selective(G_R, H) for G_R in G._right}\n right_2 = {selective(G, H_R) for H_R in H._right}\n right_3 = {selective(G_R, H_R) for G_R in G._right for H_R in H._right}\n return Game(left_1 | left_2 | left_3, right_1 | right_2 | right_3)","def select(self, gas=range(1, 12), loc=range(1, 7),\n voltage=range(1, 6), speed=range(1, 4), trial=range(1, 21),\n from_HDFcache=False):\n # cast int entries to list\n if isinstance(gas, int):\n gas = [gas]\n if isinstance(loc, int):\n loc = [loc]\n if isinstance(voltage, int):\n voltage = [voltage]\n if isinstance(speed, int):\n speed = [speed]\n if isinstance(trial, int):\n trial = [trial]\n\n # validate input\n assert min(gas) > 0 and max(gas) in self.GasNames.keys(), \\\n 'Wrong gas name: {}'.format(gas)\n assert min(loc) > 0 and max(loc) in self.Locs.keys(), \\\n 'Wrong board location: {}'.format(loc)\n assert min(voltage) > 0 and max(voltage) in self.SensorVoltages.keys(), \\\n 'Wrong sensor voltage: {}'.format(voltage)\n assert min(speed) > 0 and max(speed) in self.FanSpeeds.keys(), \\\n 'Wrong fan speed: {}'.format(speed)\n assert min(trial) > 0 and max(trial) in range(1, 21), \\\n 'Trial number out of range, must be [1,20], is [{},{}]'.format(\n min(trial), max(trial))\n\n cols = self._get_data(gas, loc, voltage, speed, trial)\n return cols","def __init__(self):\n \n # Call the super contructor\n super(Select, self).__init__(0, 0, 200, 50)\n\n # Assign personalisation attributes\n self.placeholder = \"Choose a value\"\n self.font_name: str = None\n self.font_size: int = 12\n\n self.bg_color: tuple = (0, 0, 0, 0)\n self.bg_hover: tuple = (255, 255, 255, 30)\n self.bg_press: tuple = None\n\n self.label_color: tuple = (255, 255, 255, 255)\n self.label_hover: tuple = None\n self.label_press: tuple = None\n\n self.border_color: tuple = (255, 255, 255, 255)\n self.border_hover: tuple = None\n self.border_press: tuple = None\n self.border_width: int = 4\n\n self.option_height: int = 45\n self.option_margin: int = 5\n self.option_font_name = None\n self.option_font_size = 12\n\n self.option_bg_color: tuple = (0, 0, 0, 0)\n self.option_bg_hover: tuple = (255, 255, 255, 30)\n self.option_bg_press: tuple = None\n self.option_bg_select: tuple = (255, 255, 255, 60)\n\n self.option_label_color: tuple = (255, 255, 255, 255)\n self.option_label_hover: tuple = None\n self.option_label_press: tuple = None\n self.option_label_select: tuple = None\n\n # Assign internal attributes\n self._is_hovered: bool = False\n self._is_pressed: bool = False\n self._is_opened: bool = False\n self._is_inverted: bool = False\n self._options: list = list()\n self._current_select: int = -1\n self._current_hover: int = -1\n\n self._bg = pyglet.shapes.Rectangle\n self._label = pyglet.text.Label\n self._border = Border\n\n self._option_border: Border = None\n self._options_bg: list = list()\n self._options_label: list = list()","def __init__(self, hgtStartData):\r\n self.data = []\r\n for row in hgtStartData:\r\n toAdd = []\r\n for height in row:\r\n toAdd.append([height, 0])\r\n self.data.append(toAdd)\r\n self.maxX = len(hgtStartData[0]) - 1\r\n self.maxY = len(hgtStartData) - 1\r\n\r\n self.minFloodHeight = 0","def create_interval_hsb(confidence, n_samples, data_point):\n if n_samples == 0:\n return Interval(0, 1)\n delta = margin_hsb(confidence, n_samples, data_point)\n return Interval(float(max(data_point - delta, 0)), float(min(data_point + delta, 1)))","def element(selection, sel_type='id'):\n selector = get_selector_method(sel_type)\n return selector(selection)"],"string":"[\n \"def from_selection(cls):\\n guid = compas_rhino.select_point()\\n return cls.from_guid(guid)\",\n \"def get_slider():\\n return dcc.RangeSlider(\\n id='hours',\\n value=[0, 23],\\n min=0,\\n max=23,\\n marks={i: str(i) for i in range(0, 24, 3)}\\n )\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_mesh()\\n return cls.from_guid(guid)\",\n \"def rangeselector_time():\\n return {\\n \\\"bgcolor\\\": \\\"rgb(35, 149, 86)\\\",\\n \\\"activecolor\\\": \\\"rgb(25, 108, 62)\\\",\\n \\\"buttons\\\": [\\n {\\\"count\\\": 12, \\\"label\\\": \\\"12h\\\", \\\"step\\\": \\\"hour\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"count\\\": 24, \\\"label\\\": \\\"24h\\\", \\\"step\\\": \\\"hour\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"count\\\": 48, \\\"label\\\": \\\"48h\\\", \\\"step\\\": \\\"hour\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"count\\\": 3, \\\"label\\\": \\\"3d\\\", \\\"step\\\": \\\"day\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"count\\\": 7, \\\"label\\\": \\\"7d\\\", \\\"step\\\": \\\"day\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"step\\\": \\\"all\\\"},\\n ],\\n }\",\n \"def selection(self):\\n if not self._selection:\\n return None\\n \\n year, month = self._date.year, self._date.month\\n return self.datetime(year, month, int(self._selection[0]))\",\n \"def create(cls, selection):\\n\\t\\t\\n\\t\\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })\",\n \"def from_selection(\\n class_,\\n selection,\\n item_class=None,\\n ):\\n import abjad\\n pitch_segment = abjad.PitchSegment.from_selection(selection)\\n return class_(\\n pitch_segment,\\n item_class=item_class,\\n )\",\n \"def select_hours(self, lhours):\\n sel = []\\n for i in range(self.dataset.shape[0]):\\n stime = time.localtime(np.int32(self.dataset[i][2]))\\n hour = stime[3]\\n for ih in lhours:\\n ihour, fhour = ih\\n if ihour <= hour < fhour:\\n sel.append(i)\\n data = STData(self.wpath, self.city, self.application)\\n data.dataset = self.dataset[sel]\\n return data\",\n \"def _select_by_range(self, disc_low, disc_high):\\n sqlstmt = \\\"SELECT h FROM %s WHERE d>=? and d<=?\\\" % self.VIEW\\n pickup = self.cursor.execute(sqlstmt, (disc_low, disc_high,))\\n return [h[0] for h in pickup]\",\n \"def _select_by_range(self, disc_low, disc_high):\\n sqlstmt = \\\"SELECT h FROM %s WHERE d>=? and d<=?\\\" % self.VIEW\\n pickup = self.cursor.execute(sqlstmt, (-disc_high, -disc_low))\\n return [h[0] for h in pickup]\",\n \"def selection(self):\\r\\n if not self._selection:\\r\\n print(\\\"not working\\\")\\r\\n return None\\r\\n\\r\\n year, month = self._date.year, self._date.month\\r\\n if len(str(month))==1:\\r\\n month = \\\"0{}\\\".format(month)\\r\\n return (\\\"{}{}{}\\\".format(year, month, self._selection[0]), \\r\\n \\\"{} / {} / {}\\\".format(year, month, self._selection[0]))\",\n \"def get_selection(self, selection_name, format=None):\",\n \"def makeSelection(self, selection=\\\"\\\"):\\n\\n\\t\\tif selection == \\\"\\\":\\n\\t\\t\\tprint \\\"usage: makeSelection(selection)\\\"\\n\\n\\t\\tsel_string = self.parseMacros(selection)\\n\\n\\t\\t# --- split by \\\";\\\" --- #\\n\\t\\ttmp = []\\n\\t\\tcols = []\\n\\t\\tcols = sel_string.split(\\\";\\\")\\n\\t\\tfor col in cols:\\n\\t\\t\\tinverse = False\\n\\t\\t\\tif col == \\\"\\\":\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\ttmp = string.split(col, \\\"=\\\")\\n\\t\\t\\tif \\\"!\\\" in tmp[0]:\\n\\t\\t\\t\\tinverse = True\\n\\n\\t\\t\\tif \\\"resi\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseResI(tmp[1])\\n\\t\\t\\t\\tself.invresi = inverse\\n\\t\\t\\telif \\\"resn\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseResN(tmp[1])\\n\\t\\t\\t\\tself.invresn = inverse\\n\\t\\t\\telif \\\"name\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(tmp[1])\\n\\t\\t\\t\\tself.invatom = inverse\\n\\t\\t\\telif \\\"element\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseElement(tmp[1])\\n\\t\\t\\t\\tself.invelement = inverse\\t\\n\\t\\t\\telif \\\"chain\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseChain(tmp[1])\\n\\t\\t\\t\\tself.invchain = inverse\\n\\t\\t\\telif \\\"type\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseType(tmp[1])\\n\\t\\t\\t\\tself.invtype = inverse\\n\\t\\t\\telif \\\"cat\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseCat(tmp[1])\\n\\t\\t\\t\\tself.invcat = inverse\\n\\t\\t\\telif \\\"atomid\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtomid(tmp[1])\\n\\t\\t\\t\\tself.invatomid = inverse\\n\\t\\t\\telif \\\"BB\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O \\\")\\n\\t\\t\\t\\tself.invatom = False\\n\\t\\t\\telif \\\"CEN\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O , CB \\\")\\n\\t\\t\\t\\tself.invatom = False\\n\\t\\t\\telif \\\"SC\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O \\\")\\n\\t\\t\\t\\tself.invatom = True\\n\\t\\t\\telif \\\"HET\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseType(\\\"HETATM\\\")\\n\\t\\t\\t\\tself.invtype = inverse\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint \\\"unrecognized selector: \\\",tmp[0]\\n\\t\\t\\t\\tsys.exit()\",\n \"def get_h0(self, t):\\n return self.h0\",\n \"def get_selection():\\n\\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\\n sel_len = len(selected)\\n result = SelectionContainer()\\n\\n for _x in range(0, sel_len):\\n\\n shape_type = selected[_x].ShapeType\\n\\n if shape_type == 'Vertex':\\n result.vertices.append(selected[_x])\\n\\n elif shape_type == 'Edge':\\n\\n if 'Line' in str(selected[_x].Curve):\\n result.lines.append(selected[_x])\\n else:\\n result.curves.append(selected[_x])\",\n \"def make_selection ( self ,\\n tag , \\n algotype ,\\n inputs , \\n *args ,\\n **kwargs ) :\\n sel_tag = '%s_Selection' % tag\\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\\n #\\n ## check existing selection\\n #\\n sel = self._selection ( sel_tag )\\n if sel : return sel \\n\\n #\\n ## adjust a bit the arguments\\n if not kwargs.has_key('Preambulo') :\\n kwargs ['Preambulo' ] = self['Preambulo']\\n\\n if not kwargs.has_key( 'ParticleCombiners' ) :\\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \\n \\n # \\n ## use \\\"simple-selection\\\"\\n #\\n from PhysSelPython.Wrappers import SimpleSelection\\n sel = SimpleSelection (\\n sel_name ,\\n algotype ,\\n inputs , \\n *args ,\\n **kwargs )\\n # \\n return self._add_selection( sel_tag , sel )\",\n \"def build_selection_spec(client_factory, name):\\r\\n sel_spec = client_factory.create('ns0:SelectionSpec')\\r\\n sel_spec.name = name\\r\\n return sel_spec\",\n \"def getSect(self, h):\\n coordtrasp=self.coord.T\\n lefttomin=self.coord[1][:self.min+1]\\n # left point\\n lpnt = self.firstPointAfter_h(lefttomin[::-1], h)\\n # find index of left point\\n l_pnt = self.min - lpnt\\n # find left intersection\\n l_intersect = self.intersection(coordtrasp[l_pnt], coordtrasp[l_pnt+1], h)\\n # right point\\n rpnt = self.firstPointAfter_h(self.coord[1][self.min:], h)\\n # find index of right point\\n r_pnt = self.min + rpnt\\n # find right intersection\\n r_intersect = self.intersection(coordtrasp[r_pnt], coordtrasp[r_pnt-1], h)\\n # make new section geometries\\n sez = coordtrasp[l_pnt+1:r_pnt]\\n # Add left intersection on the top\\n sez=np.insert(sez, [0,], l_intersect,axis=0)\\n # Add rightht intersection on the bottom\\n sez=np.append(sez,[r_intersect],axis=0)\\n return sez\",\n \"def createSelector(self,type='select',speed=2.0):\\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector.hide()\\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def createSelector2(self,type='select',speed=2.0):\\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector2.hide()\\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def cdd_Hrepresentation(self):\\n return cdd_Hrepresentation(self._cdd_type, \\n [i for i in self.inequalities()],\\n [e for e in self.equation_generator()] )\",\n \"def _add_selection ( self , nick , sel ) :\\n if not self.__selections_.has_key ( self.name() ) :\\n self.__selections_[ self.name() ] = {} \\n \\n if self.__selections_[ self.name()].has_key( nick ) :\\n raise AttributeError , \\\"Selection '%s'already exists \\\" % nick\\n \\n self.__selections_[ self.name() ][ nick ] = sel\\n \\n return sel\",\n \"def shortened_selective(G, H):\\n if G == 0 or H == 0:\\n return Game(0)\\n else:\\n left_1 = {shortened_selective(G_L, H) for G_L in G._left}\\n left_2 = {shortened_selective(G, H_L) for H_L in H._left}\\n left_3 = {shortened_selective(G_L, H_L) for G_L in G._left for H_L in H._left}\\n right_1 = {shortened_selective(G_R, H) for G_R in G._right}\\n right_2 = {shortened_selective(G, H_R) for H_R in H._right}\\n right_3 = {shortened_selective(G_R, H_R) for G_R in G._right for H_R in H._right}\\n return Game(left_1 | left_2 | left_3, right_1 | right_2 | right_3)\",\n \"def __hour(self):\\n return _VirtualColumn(\\n df_name=self.thisptr[\\\"df_name_\\\"],\\n operator=\\\"hour\\\",\\n operand1=self,\\n operand2=None\\n )\",\n \"def add_selector(self, listing):\\n # We will be able to select X-frames and its boundaries\\n # will be stored in the given list\\n\\n def onselect(xmin, xmax):\\n# indmin, indmax = np.searchsorted(x, (xmin, xmax))\\n# indmax = min(len(x)-1, indmax)\\n indmin = xmin\\n indmax = xmax\\n onselect.listing.append([indmin, indmax])\\n print (onselect.listing)\\n \\n onselect.listing = listing\\n \\n # set useblit True on gtkagg for enhanced performance\\n ax = self.axes\\n span = SpanSelector(ax, onselect, 'horizontal', useblit=True,\\n rectprops=dict(alpha=0.5, facecolor='red') )\\n \\n self.widget_list.append(span)\",\n \"def data_selection(data, columnX=\\\"time\\\", columnY=\\\"forceX\\\", ylim=None):\\n\\n fig = plt.figure(figsize=(8, 6))\\n ax = fig.add_subplot(111)\\n if ylim is not None:\\n ax.set_ylim(ylim[0], ylim[1])\\n x = data[columnX]\\n y = data[columnY]\\n ax.plot(x, y, '-')\\n\\n fig.suptitle(\\\"Press any key to confirm selection and close this window\\\", fontsize=14, fontweight='bold')\\n ax.set_title(\\\"Select data by dragging the mouse\\\")\\n\\n def onselect(xmin, xmax):\\n \\\"\\\"\\\"\\n Sub-function to assign the minimum and maximum of the range and plot the selection\\\"\\n\\n Args:\\n xmin (int): minimum index of selection\\n xmax (int): maximum index of selection\\n \\\"\\\"\\\"\\n global indmin\\n global indmax\\n global span\\n\\n try:\\n span.remove()\\n fig.canvas.draw()\\n except:\\n pass\\n\\n indmin, indmax = np.searchsorted(x, (xmin, xmax))\\n indmax = min(len(x) - 1, indmax)\\n ax.axvspan(x.values[int(indmin)], x.values[int(indmax)], facecolor=\\\"red\\\", alpha=0.5)\\n fig.canvas.draw()\\n\\n # set useblit True on gtkagg for enhanced performance\\n span = SpanSelector(ax, onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red'))\\n mng = plt.get_current_fig_manager()\\n mng.window.showMaximized()\\n plt.show()\\n\\n while True:\\n wait = plt.waitforbuttonpress(timeout=60)\\n if wait:\\n plt.close('all')\\n break\\n else:\\n pass\\n\\n idCol = column_indexer(data)\\n mask = (data[columnX] >= data.iloc[indmin, idCol[columnX]]) & \\\\\\n (data[columnX] <= data.iloc[indmax, idCol[columnX]])\\n subData = data.loc[mask, :]\\n\\n return subData\",\n \"def hour(self) -> Index:\\n warnings.warn(\\n \\\"`hour` will return int32 index instead of int 64 index in 4.0.0.\\\",\\n FutureWarning,\\n )\\n return Index(self.to_series().dt.hour)\",\n \"def care_color_HH(selection):\\n acids = \\\"{} and (resn ASP or resn ASH or resn GLU or resn GLH)\\\".format(selection)\\n bases = \\\"{} and (resn HIS or resn HIE or resn HID or resn HIP or resn ARG \\\\\\n or resn LYS or resn LYN)\\\".format(selection)\\n polars = \\\"{} and (resn CYS or resn CYX or resn GLN or resn ASN or resn SER \\\\\\n or resn TYR or resn THR)\\\".format(selection)\\n nonpolars = \\\"{} and (resn GLY or resn ALA or resn LEU or resn ILE or resn PHE \\\\\\n or resn TRP or resn MET or resn PRO or resn VAL)\\\".format(selection)\\n cmd.color(\\\"firebrick\\\", acids)\\n cmd.color(\\\"deepteal\\\", bases)\\n cmd.color(\\\"tv_orange\\\", polars)\\n cmd.color(\\\"smudge\\\", nonpolars)\\n util.cnc(selection)\",\n \"def _get_range(self):\\n return tuple((0, m, 1) for m in self.level_shapes[0])\",\n \"def _getAsSelection(self):\\n return self._asSelection\",\n \"def get_gold_selection(self, pointer):\\n raise NotImplementedError\",\n \"def get_gti_from_hdu(gtihdu):\\n gtitable = gtihdu.data\\n\\n colnames = [col.name for col in gtitable.columns]\\n # Default: NuSTAR: START, STOP. Otherwise, try RXTE: Start, Stop\\n if \\\"START\\\" in colnames:\\n startstr, stopstr = \\\"START\\\", \\\"STOP\\\"\\n else:\\n startstr, stopstr = \\\"Start\\\", \\\"Stop\\\"\\n\\n gtistart = np.array(gtitable.field(startstr), dtype=np.longdouble)\\n gtistop = np.array(gtitable.field(stopstr), dtype=np.longdouble)\\n gti_list = np.vstack((gtistart, gtistop)).T\\n\\n return gti_list\",\n \"def rangeselector_date():\\n return {\\n \\\"bgcolor\\\": \\\"rgb(35, 149, 86)\\\",\\n \\\"activecolor\\\": \\\"rgb(25, 108, 62)\\\",\\n \\\"buttons\\\": [\\n {\\\"count\\\": 7, \\\"label\\\": \\\"1w\\\", \\\"step\\\": \\\"day\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"count\\\": 14, \\\"label\\\": \\\"2w\\\", \\\"step\\\": \\\"day\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"count\\\": 1, \\\"label\\\": \\\"1m\\\", \\\"step\\\": \\\"month\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"count\\\": 3, \\\"label\\\": \\\"3m\\\", \\\"step\\\": \\\"month\\\", \\\"stepmode\\\": \\\"backward\\\"},\\n {\\\"step\\\": \\\"all\\\"},\\n ],\\n }\",\n \"def select_time(new_cube, lower, upper):\\n\\n sliced_cube = new_cube.extract(iris.Constraint(year=lambda y: lower<=y<=upper))\\n\\n return sliced_cube\",\n \"def select(cursor, q, expire_after=None):\\n if expire_after:\\n query = \\\"\\\"\\\"SELECT h.* FROM hasil h\\n JOIN pencarian p ON (p.id=h.query_id)\\n WHERE p.query=:query and \\n CAST( \\n (JULIANDAY('now', 'localtime') - JULIANDAY(p.timestamp)) \\n AS INTEGER) <= :expire_after\\\"\\\"\\\"\\n \\n rows = cursor.execute(query, {'query': q,\\n 'expire_after': expire_after})\\n return HasilCollections(rows)\\n raise NotImplementedError\",\n \"def start(self):\\n return _uhd_swig.range_t_start(self)\",\n \"def __init__(self,\\n h=0.01):\\n super().__init__(1, 100000000,\\n 1, 1,\\n 5, 10,\\n 0, -1, h)\",\n \"def horde_start(self, observation):\",\n \"def __call__(self) -> abjad.Selection:\\n if (self._repetition_chance == 0.0\\n or random.random() > self._repetition_chance):\\n if not self._is_first_window or self._process_on_first_call:\\n if self._mode == 'out':\\n self._remove_element()\\n else:\\n self._add_element()\\n elif not self._include_empty_measures and self._mode == 'in':\\n self._add_element()\\n self._mask_to_selection()\\n return self.current_window\",\n \"def get_selection(\\n cls,\\n selections: list[str],\\n title: str = \\\"\\\",\\n subtitle: str = \\\"\\\",\\n ) -> int:\\n menu = cls.make_selection_menu(\\n selections=selections,\\n title=title,\\n subtitle=subtitle,\\n show_exit_item=False,\\n )\\n return cast(int, menu.show())\",\n \"def blankUpdateRange(dayHour):\\n return { 'position': dayHour, 'updateHistory': [dayHour], 'width': Predictor.rangeWidth }\",\n \"def roi_hdu_from_sel(\\n sel_image: np.ndarray,\\n color_ix: int,\\n eye_name: str,\\n instrument: str = \\\"MCAM\\\",\\n sel_fn: str = None,\\n) -> fits.PrimaryHDU:\\n roi_array = select_roi_by_ix(sel_image, color_ix)\\n color_name = roi_color_ix_to_color_name(color_ix, instrument)\\n merspect_metadata = {\\\"EYE\\\": eye_name, \\\"SOURCEFN\\\": Path(sel_fn).name}\\n roi_hdu = make_roi_hdu(roi_array, color_name, merspect_metadata)\\n roi_hdu.name = color_name + \\\" \\\" + eye_name\\n return roi_hdu\",\n \"def _select_single(self, disc):\\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)\",\n \"def make_selection_menu(\\n cls,\\n selections: list[str],\\n title: str = \\\"\\\",\\n subtitle: str = \\\"\\\",\\n *,\\n show_exit_item: bool = False,\\n ) -> CursesMenu:\\n menu = cls(title=title, subtitle=subtitle, show_exit_item=show_exit_item)\\n from cursesmenu.items.selection_item import SelectionItem\\n\\n for index, selection in enumerate(selections):\\n menu.items.append(\\n SelectionItem(text=selection, index=index, should_exit=True),\\n )\\n return menu\",\n \"def extract_H_ranges(Work: dict) -> str:\\n work_H_rows = Work[\\\"libE_info\\\"][\\\"H_rows\\\"]\\n if len(work_H_rows) == 1:\\n return str(work_H_rows[0])\\n else:\\n # From https://stackoverflow.com/a/30336492\\n ranges = []\\n for diff, group in groupby(enumerate(work_H_rows.tolist()), lambda x: x[0] - x[1]):\\n group = list(map(itemgetter(1), group))\\n if len(group) > 1:\\n ranges.append(str(group[0]) + \\\"-\\\" + str(group[-1]))\\n else:\\n ranges.append(str(group[0]))\\n return \\\"_\\\".join(ranges)\",\n \"def select_bounds(ds, bounds):\\n \\n xs = slice(bounds[0][0], bounds[1][0])\\n ys = slice(bounds[1][1], bounds[0][1])\\n # select over x and y axis\\n return ds.sel(x=xs, y=ys)\",\n \"def get_geometry(self, selection_name):\",\n \"def generate_24hrs():\\n\\n hrs = []\\n\\n for i in xrange(1, 25):\\n hrs.append([i, 0])\\n\\n return hrs\",\n \"def _getHyperslabSlices(dsetshape, select):\\n\\n if select is None:\\n # Default: return entire dataset\\n return tuple(slice(0, extent) for extent in dsetshape)\\n\\n if not select.startswith('['):\\n msg = \\\"Bad Request: selection query missing start bracket\\\"\\n raise HTTPError(400, reason=msg)\\n if not select.endswith(']'):\\n msg = \\\"Bad Request: selection query missing end bracket\\\"\\n raise HTTPError(400, reason=msg)\\n\\n # strip brackets\\n select = select[1:-1]\\n\\n select_array = select.split(',')\\n if len(select_array) > len(dsetshape):\\n msg = \\\"Bad Request: number of selected dimensions exceeds the rank of the dataset\\\"\\n raise HTTPError(400, reason=msg)\\n\\n slices = []\\n for dim, dim_slice in enumerate(select_array):\\n extent = dsetshape[dim]\\n\\n # default slice values\\n start = 0\\n stop = extent\\n step = 1\\n if dim_slice.find(':') < 0:\\n # just a number - return slice(start, start + 1, 1) for this dimension\\n try:\\n start = int(dim_slice)\\n except ValueError:\\n msg = \\\"Bad Request: invalid selection parameter (can't convert to int) for dimension: \\\" + str(dim)\\n raise HTTPError(400, reason=msg)\\n stop = start + 1\\n elif dim_slice == ':':\\n # select everything (default)\\n pass\\n else:\\n fields = dim_slice.split(\\\":\\\")\\n if len(fields) > 3:\\n msg = \\\"Bad Request: Too many ':' seperators for dimension: \\\" + str(dim)\\n raise HTTPError(400, reason=msg)\\n try:\\n if fields[0]:\\n start = int(fields[0])\\n if fields[1]:\\n stop = int(fields[1])\\n if len(fields) > 2 and fields[2]:\\n step = int(fields[2])\\n except ValueError:\\n msg = \\\"Bad Request: invalid selection parameter (can't convert to int) for dimension: \\\" + str(dim)\\n raise HTTPError(400, reason=msg)\\n\\n if start < 0 or start > extent:\\n msg = \\\"Bad Request: Invalid selection start parameter for dimension: \\\" + str(dim)\\n raise HTTPError(400, reason=msg)\\n if stop > extent:\\n msg = \\\"Bad Request: Invalid selection stop parameter for dimension: \\\" + str(dim)\\n raise HTTPError(400, reason=msg)\\n if step <= 0:\\n msg = \\\"Bad Request: invalid selection step parameter for dimension: \\\" + str(dim)\\n raise HTTPError(400, reason=msg)\\n slices.append(slice(start, stop, step))\\n\\n return tuple(slices)\",\n \"def __init__(self):\\n self.minh = []\\n self.maxh = []\",\n \"def create_selector_bcg(self, bcg_sd, bcg_time):\\n bcg_nr = self.time_to_number(bcg_time)\\n bcg = self.filter_line.iloc[0:bcg_nr].mean()\\n std = self.filter_line.iloc[0:bcg_nr].std()\\n ind = [True if value > bcg+bcg_sd *\\n std else False for value in self.filter_line]\\n ind2 = ind[1:]\\n ind2.append(False)\\n index = [i for i in range(0, len(ind)) if ind[i] != ind2[i]]\\n\\n self.starts = [index[i] for i in range(len(index)) if i % 2 == 0]\\n self.ends = [index[i] for i in range(len(index)) if i % 2 != 0]\\n\\n self.create_on_off()\",\n \"def _select_all(self):\\n sqlstmt = \\\"SELECT d, h FROM %s\\\" % self.VIEW\\n return [(-d, h) for (d, h) in self.cursor.execute(sqlstmt)]\",\n \"def get_selection_first_coord(sel, name=\\\"(sel)\\\"):\\n\\n #print \\\"--> selection %(name)s: %(sel)s\\\" % vars()\\n cmd.select(name, sel)\\n try:\\n return numpy.array(cmd.get_model(name).atom[0].coord)\\n except IndexError:\\n print \\\"--> empty selection: %(sel)s\\\" % vars()\\n raise\",\n \"def define_range():\\n\\n def_range = {'lt': [0.0, 24.0],\\n 'lon': [0.0, 360.0],\\n 'angle': [0.0, 2.0 * np.pi]}\\n\\n return def_range\",\n \"def _generateTimeSelector(self, dParams, sPreamble, sPostamble):\\n\\n if WuiDispatcherBase.ksParamEffectiveDate in dParams:\\n tsEffective = dParams[WuiDispatcherBase.ksParamEffectiveDate]\\n del dParams[WuiDispatcherBase.ksParamEffectiveDate]\\n else:\\n tsEffective = ''\\n\\n # Forget about page No when changing a period\\n if WuiDispatcherBase.ksParamPageNo in dParams:\\n del dParams[WuiDispatcherBase.ksParamPageNo]\\n\\n sHtmlTimeSelector = '<form name=\\\"TimeForm\\\" method=\\\"GET\\\">\\\\n'\\n sHtmlTimeSelector += sPreamble;\\n sHtmlTimeSelector += '\\\\n <select name=\\\"%s\\\" onchange=\\\"window.location=' % WuiDispatcherBase.ksParamEffectiveDate\\n sHtmlTimeSelector += '\\\\'?%s&%s=\\\\' + ' % (webutils.encodeUrlParams(dParams), WuiDispatcherBase.ksParamEffectiveDate)\\n sHtmlTimeSelector += 'this.options[this.selectedIndex].value;\\\" title=\\\"Effective date\\\">\\\\n'\\n\\n aoWayBackPoints = [\\n ('+0000-00-00 00:00:00.00', 'Now', ' title=\\\"Present Day. Present Time.\\\"'), # lain :)\\n\\n ('-0000-00-00 01:00:00.00', '1 hour ago', ''),\\n ('-0000-00-00 02:00:00.00', '2 hours ago', ''),\\n ('-0000-00-00 03:00:00.00', '3 hours ago', ''),\\n\\n ('-0000-00-01 00:00:00.00', '1 day ago', ''),\\n ('-0000-00-02 00:00:00.00', '2 days ago', ''),\\n ('-0000-00-03 00:00:00.00', '3 days ago', ''),\\n\\n ('-0000-00-07 00:00:00.00', '1 week ago', ''),\\n ('-0000-00-14 00:00:00.00', '2 weeks ago', ''),\\n ('-0000-00-21 00:00:00.00', '3 weeks ago', ''),\\n\\n ('-0000-01-00 00:00:00.00', '1 month ago', ''),\\n ('-0000-02-00 00:00:00.00', '2 months ago', ''),\\n ('-0000-03-00 00:00:00.00', '3 months ago', ''),\\n ('-0000-04-00 00:00:00.00', '4 months ago', ''),\\n ('-0000-05-00 00:00:00.00', '5 months ago', ''),\\n ('-0000-06-00 00:00:00.00', 'Half a year ago', ''),\\n\\n ('-0001-00-00 00:00:00.00', '1 year ago', ''),\\n ]\\n fSelected = False;\\n for sTimestamp, sWayBackPointCaption, sExtraAttrs in aoWayBackPoints:\\n if sTimestamp == tsEffective:\\n fSelected = True;\\n sHtmlTimeSelector += ' <option value=\\\"%s\\\"%s%s>%s</option>\\\\n' \\\\\\n % (webutils.quoteUrl(sTimestamp),\\n ' selected=\\\"selected\\\"' if sTimestamp == tsEffective else '',\\n sExtraAttrs, sWayBackPointCaption)\\n if not fSelected and tsEffective != '':\\n sHtmlTimeSelector += ' <option value=\\\"%s\\\" selected>%s</option>\\\\n' \\\\\\n % (webutils.quoteUrl(tsEffective), tsEffective)\\n\\n sHtmlTimeSelector += ' </select>\\\\n';\\n sHtmlTimeSelector += sPostamble;\\n sHtmlTimeSelector += '\\\\n</form>\\\\n'\\n\\n return sHtmlTimeSelector\",\n \"def _select_single(self, disc):\\n sqlstmt = \\\"SELECT h FROM %s WHERE d=?\\\" % self.VIEW\\n pickup = self.cursor.execute(sqlstmt, (disc,))\\n picked = pickup.fetchone()\\n if picked is not None:\\n # picked = (h,)\\n return picked[0]\\n else:\\n raise KeyError(str(disc))\",\n \"def Clone(self) -> \\\"itkIsoDataThresholdCalculatorHDUS_Pointer\\\":\\n return _itkIsoDataThresholdCalculatorPython.itkIsoDataThresholdCalculatorHDUS_Clone(self)\",\n \"def __init__(self, id, interval, times=0, q=0, s=0):\\n self.id = id\\n self.interval = interval\\n self.times = times\\n self.q = q\\n self.s = s\",\n \"def start(self):\\n return _uhd_swig.meta_range_t_start(self)\",\n \"def get_range(g,h,d): # g: graph; h: head node; d: dependent node\\n addresses = sorted(g.nodes.keys())\\n h_index = addresses.index(h)\\n d_index = addresses.index(d)\\n sign = cmp(d_index,h_index)\\n return addresses[h_index:d_index+sign:sign]\",\n \"def from_harte_interval(cls, harte_interval_string):\\n if isinstance(harte_interval_string, int):\\n harte_interval_string = str(harte_interval_string)\\n harte_interval_string = harte_interval_string.strip(' ')\\n return cls(find_item(HARTE_INTERVALS, harte_interval_string))\",\n \"def from_hff(cls, hff_data, name=None, args=None):\\n _assert_or_raise(hff_data, h5py.Group)\\n obj = cls(new_obj=False)\\n if u'xmin' in hff_data:\\n obj.xmin = hff_data[u'xmin'][()]\\n if u'xmax' in hff_data:\\n obj.xmax = hff_data[u'xmax'][()]\\n if u'ymin' in hff_data:\\n obj.ymin = hff_data[u'ymin'][()]\\n if u'ymax' in hff_data:\\n obj.ymax = hff_data[u'ymax'][()]\\n if u'zmin' in hff_data:\\n obj.zmin = hff_data[u'zmin'][()]\\n if u'zmax' in hff_data:\\n obj.zmax = hff_data[u'zmax'][()]\\n return obj\",\n \"def select(self):\\n pass\",\n \"def select(self):\\n pass\",\n \"def viewport_selection():\\n sel = oMa.MGlobal.getActiveSelectionList()\\n\\n for i in range(sel.length()):\\n m_obj = sel.getDependNode(i)\\n yield m_obj\",\n \"def get_empty_obj(ch_temp):\\n return ChData(None, time_type.TimeType(), ch_temp)\",\n \"def Clone(self) -> \\\"itkIsoDataThresholdCalculatorHDSS_Pointer\\\":\\n return _itkIsoDataThresholdCalculatorPython.itkIsoDataThresholdCalculatorHDSS_Clone(self)\",\n \"def h(self, x, u, t):\\n \\n x, z = self._split_states( x )\\n \\n y = self.plant.h( x, u, t)\\n \\n return y\",\n \"def _selection ( self, nick ) :\\n \\n if not self.__selections_.has_key ( self.name() ) :\\n self.__selections_[ self.name() ] = {} \\n \\n return self.__selections_[ self.name() ].get( nick , None )\",\n \"def hxlselect():\\n run_script(hxlselect_main)\",\n \"def convex_hull(self):\\n return self._geomgen(capi.geom_convex_hull)\",\n \"def New(*args, **kargs):\\n obj = itkIsoDataThresholdCalculatorHDUC.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def New(*args, **kargs):\\n obj = itkIsoDataThresholdCalculatorHDSS.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def __init__(self):\\n self.intervalList = [] # intervalList is a table with \\\"start\\\" and \\\"end\\\" columns indicating the start and end of each interval\",\n \"def select(self):\\n\\n return self.p[0], self.p[1]\",\n \"def makeDstarPartial( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n daugCuts = \\\"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\\\" % locals()['config']\\n combCuts = \\\"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\\\" % locals()['config']\\n dstarCuts = \\\"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\\\" \\\\\\n \\\"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\\\" % locals()['config']\\n\\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"pi+\\\" : daugCuts }\\n , CombinationCut = combCuts\\n , MotherCut = dstarCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dstar,\\n RequiredSelections = inputSel\\n )\",\n \"def raster_time_select_list(self, selected_field, selected_list_state, selected_list_id, is_readonly, select_list_initial_msg):\\n\\n raster_time_name_value_dic = {'name': ['2', '4'], 'value': ['2', '4']}\\n return make_select_list_using_dictionary(raster_time_name_value_dic, selected_field, selected_list_state, selected_list_id, is_readonly, select_list_initial_msg)\",\n \"def makeDstar2D0Pi( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n daugCuts = \\\"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\\\" % locals()['config']\\n combCuts = \\\"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\\\" % locals()['config']\\n dstarCuts = \\\"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\\\" \\\\\\n \\\"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\\\" % locals()['config']\\n\\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"pi+\\\" : daugCuts }\\n , CombinationCut = combCuts\\n , MotherCut = dstarCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dstar,\\n RequiredSelections = inputSel\\n )\",\n \"def select(self):\\r\\n pass\",\n \"def selectaround(document, selection=None):\\n selection = selection or document.selection\\n default_chars = ['{', '[', '(', '<', '\\\\'', '\\\"']\\n candidates = []\\n for char in default_chars:\\n candidate = selectaround_char(document, char, selection)\\n if candidate != None:\\n candidates.append(candidate)\\n if candidates:\\n # Select smallest enclosing candidate\\n return min(candidates, key=avg_interval_length)\",\n \"def getHourColumn(self): \\n return self.hourcol\",\n \"def get_selection(self, pointer, answer_sheet, sel_none_of_above):\\n def answer_parsing(answer_str):\\n selections = answer_str.split(\\\", \\\")\\n try:\\n selections = [int(sel) for sel in selections]\\n except:\\n return None\\n else:\\n assert len(selections)\\n if sel_none_of_above in selections:\\n assert len(selections) == 1 # mutual exclusive \\\"none of the above\\\"\\n return selections\\n\\n answer = input(\\\"Please enter the option id(s) delimited by comma ', ': \\\")\\n selections = answer_parsing(answer)\\n while selections is None:\\n answer = input(\\\"Please enter the option id(s) delimited by comma ', ': \\\")\\n selections = answer_parsing(answer)\\n\\n return selections\",\n \"def select(self):\\n return\",\n \"def get_buffer_selection (buffer):\\n bounds = buffer.get_selection_bounds()\\n if len(bounds) == 0:\\n return \\\"\\\"\\n else:\\n return buffer.get_slice(*bounds)\",\n \"def parse_range(option):\\n return {\\\"range\\\": timedelta(days=option)}\",\n \"def horde_init(self, horde_info= {}):\",\n \"def get_header_table(self , dt, ds = '' , all_ds = '', length = ''):\\n index_low = self.unique_dates[ds]['indices'][dt]['low']\\n #index_up = self.unique_dates[best_ds]['indices'][dt]['up'] \\n hd = self.data[ds]['header_table'][index_low:index_low+length] \\n hd['duplicates'] = all_ds \\n \\n return hd\",\n \"def __getSelectionFilter(self):\\n \\n selectionPairs = []\\n selectionPairs.append(('field','field'))\\n selectionPairs.append(('spw','spw'))\\n selectionPairs.append(('polarization','correlation'))\\n selectionPairs.append(('baseline','antenna'))\\n selectionPairs.append(('time','timerange'))\\n selectionPairs.append(('scan','scan'))\\n selectionPairs.append(('uvdist','uvrange'))\\n selectionPairs.append(('scanintent','intent'))\\n selectionPairs.append(('observation','observation'))\\n return self.__generateFilter(selectionPairs)\",\n \"def __chanSelection(self, spwsel):\\n \\n # Split to get each spw in a list\\n if spwsel.__contains__(','):\\n spwlist = spwsel.split(',') \\n else:\\n spwlist = spwsel.split(';')\\n \\n spwid=[]\\n chanlist=[]\\n # Split to create two lists, one with channels, the other with spwIDs\\n for isel in spwlist:\\n # Get tail, colon and head\\n (s, c, ch) = isel.rpartition(\\\":\\\")\\n # Remove any blanks\\n s = s.strip(' ')\\n c = c.strip(' ')\\n ch = ch.strip(' ')\\n # If no tail, there was no colon to split. In this case, add the spwID\\n if s == \\\"\\\":\\n spwid.append(ch)\\n chanlist.append('')\\n else:\\n spwid.append(s)\\n chanlist.append(ch)\\n \\n # Create a dictionary\\n seldict = {}\\n for ns in xrange(len(spwid)):\\n sel = {}\\n sel['spw'] = spwid[ns]\\n sel['channels'] = chanlist[ns]\\n seldict[ns] = sel\\n\\n\\n return seldict\",\n \"def __init__(self, time=0, uni=None, dmx=None):\\n self.time = time\\n self.dmx = {}\\n if uni and dmx:\\n self.dmx[uni] = dmx\",\n \"def add_hic_interval_subparser(subparsers):\\n parser = subparsers.add_parser(\\\"hic-interval\\\",\\n help=\\\"HiFive Binning Function: Create a tabular interaction file containing data from a HiFive HiC project. Data are a genomic-interval format (chr1 start1 stop1 chr2 start2 stop2).\\\")\\n parser.add_argument(\\\"-c\\\", \\\"--chromosome\\\", dest=\\\"chrom\\\", default=None, required=True, type=str,\\n help=\\\"The chromosome from which to pull interaction data from.\\\")\\n parser.add_argument(\\\"--chromosome2\\\", dest=\\\"chrom2\\\", default=None, required=False, type=str,\\n help=\\\"The second chromosome from which to pull interaction data from if pulling trans data.\\\")\\n parser.add_argument(\\\"-s\\\", \\\"--start\\\", dest=\\\"start\\\", default=None, required=False, type=int,\\n help=\\\"The start coordinate of the pulled region to return. (None indicates the first valid bin on the chromosome) [default %(default)s]\\\")\\n parser.add_argument(\\\"-e\\\", \\\"--stop\\\", dest=\\\"stop\\\", default=None, required=False, type=int,\\n help=\\\"The stop coordinate of the pulled region to return. (None indicates the last valid bin on the chromosome) [default %(default)s]\\\")\\n parser.add_argument(\\\"--start2\\\", dest=\\\"start2\\\", default=None, required=False, type=int,\\n help=\\\"The start coordinate of the second chromosome pulled region to return. (None indicates the first valid bin on the chromosome) [default %(default)s]\\\")\\n parser.add_argument(\\\"--stop2\\\", dest=\\\"stop2\\\", default=None, required=False, type=int,\\n help=\\\"The stop coordinate of the second chromosome pulled region to return. (None indicates the last valid bin on the chromosome) [default %(default)s]\\\")\\n parser.add_argument(\\\"-b\\\", \\\"--binsize\\\", dest=\\\"binsize\\\", default=10000, type=int,\\n help=\\\"The size of bins, in base pairs, to group data into. [default: %(default)s]\\\")\\n parser.add_argument(\\\"-m\\\", \\\"--max-distance\\\", dest=\\\"maxdist\\\", default=None, type=int,\\n help=\\\"The maximum interaction distance to return (None indicates no maximum). [default: %(default)s]\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--data-type\\\", dest=\\\"datatype\\\", default=\\\"fend\\\",\\n help=\\\"Which corrections (if any) to apply to counts. [default: %(default)s]\\\",\\n choices=[\\\"raw\\\", \\\"fend\\\", \\\"distance\\\", \\\"enrichment\\\", \\\"expected\\\"])\\n parser.add_argument(\\\"-M\\\", \\\"--matrix\\\", dest=\\\"matrix\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Store output as a tab-separated matrix of values.\\\")\\n parser.add_argument(\\\"-y\\\", \\\"--dynamically-bin\\\", dest=\\\"dynamic\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Dynamically bin heatmap.\\\")\\n parser.add_argument(\\\"-x\\\", \\\"--expansion-binsize\\\", dest=\\\"expbinsize\\\", default=10000, type=int,\\n help=\\\"The size of bins, in base pairs, to group data into for expanding under-populated bins. [default: %(default)s]\\\")\\n parser.add_argument(\\\"-f\\\", \\\"--minobservations\\\", dest=\\\"minobs\\\", default=20, type=int,\\n help=\\\"The minimum number of observed reads in a bin for it to be considered valid. [default: %(default)s]\\\")\\n parser.add_argument(\\\"-a\\\", \\\"--search-distance\\\", dest=\\\"search\\\", default=0, type=int,\\n help=\\\"The furthest distance from the bin minpoint to expand bounds. If set to zero, there is no limit on expansion distance. [default: %(default)s]\\\")\\n parser.add_argument(\\\"-v\\\", \\\"--remove-failed\\\", dest=\\\"remove\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"If a non-zero 'search-distance' is given, it is possible for a bin not to meet the 'minobservations' criteria before stopping looking. If this occurs and 'remove-failed' is set, the observed and expected values for that bin are zero.\\\")\\n parser.add_argument(\\\"-i\\\", \\\"--image-file\\\", dest=\\\"image\\\", default=None, type=str,\\n help=\\\"Save the data as an image to this file.\\\")\\n parser.add_argument(\\\"-p\\\", \\\"--pdf\\\", dest=\\\"pdf\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Format the image in PDF format. [default: %(default)s]\\\")\\n parser.add_argument(\\\"-r\\\", \\\"--rotate\\\", dest=\\\"rotate\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Rotate the plot 45 degrees (cis binned only). [default: %(default)s]\\\")\\n parser.add_argument(\\\"-t\\\", \\\"--ticks\\\", dest=\\\"ticks\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Add tick marks and labels to the plot (pdf format and binned only). [default: %(default)s]\\\")\\n parser.add_argument(\\\"-l\\\", \\\"--legend\\\", dest=\\\"legend\\\", default=False, action=\\\"store_true\\\",\\n help=\\\"Add color scale to the plot (pdf format only). [default: %(default)s]\\\")\\n parser.add_argument(\\\"-k\\\", \\\"--keyword\\\", dest=\\\"keywords\\\", default=[], type=str, action='append',\\n help=\\\"Additional keyword arguments to pass to plotting function.\\\")\\n add_silent_argument(parser)\\n parser.add_argument(dest=\\\"project\\\", type=str,\\n help=\\\"The name of a HiFive HiC project file to pull data from.\\\")\\n parser.add_argument(dest=\\\"output\\\", type=str,\\n help=\\\"The name of the file to write HiC interval to.\\\")\\n return\",\n \"def create_ham(self):\\n from tcc.interaction import HAM_SPINLESS_RI_CORE\\n return HAM_SPINLESS_RI_CORE(self)\",\n \"def create_ham(self):\\n from tcc.interaction import HAM_SPINLESS_RI_CORE\\n return HAM_SPINLESS_RI_CORE(self)\",\n \"def generate_access_time_plot_from_range(id_range, val):\\n segments = []\\n points = []\\n\\n for i in id_range:\\n if isinstance(i, list):\\n endpoints = [(i[0], val), (i[1], val)]\\n segments.append(endpoints)\\n else:\\n points.append((i, val))\\n return segments, points\",\n \"def selective(G, H):\\n left_1 = {selective(G_L, H) for G_L in G._left}\\n left_2 = {selective(G, H_L) for H_L in H._left}\\n left_3 = {selective(G_L, H_L) for G_L in G._left for H_L in H._left}\\n right_1 = {selective(G_R, H) for G_R in G._right}\\n right_2 = {selective(G, H_R) for H_R in H._right}\\n right_3 = {selective(G_R, H_R) for G_R in G._right for H_R in H._right}\\n return Game(left_1 | left_2 | left_3, right_1 | right_2 | right_3)\",\n \"def select(self, gas=range(1, 12), loc=range(1, 7),\\n voltage=range(1, 6), speed=range(1, 4), trial=range(1, 21),\\n from_HDFcache=False):\\n # cast int entries to list\\n if isinstance(gas, int):\\n gas = [gas]\\n if isinstance(loc, int):\\n loc = [loc]\\n if isinstance(voltage, int):\\n voltage = [voltage]\\n if isinstance(speed, int):\\n speed = [speed]\\n if isinstance(trial, int):\\n trial = [trial]\\n\\n # validate input\\n assert min(gas) > 0 and max(gas) in self.GasNames.keys(), \\\\\\n 'Wrong gas name: {}'.format(gas)\\n assert min(loc) > 0 and max(loc) in self.Locs.keys(), \\\\\\n 'Wrong board location: {}'.format(loc)\\n assert min(voltage) > 0 and max(voltage) in self.SensorVoltages.keys(), \\\\\\n 'Wrong sensor voltage: {}'.format(voltage)\\n assert min(speed) > 0 and max(speed) in self.FanSpeeds.keys(), \\\\\\n 'Wrong fan speed: {}'.format(speed)\\n assert min(trial) > 0 and max(trial) in range(1, 21), \\\\\\n 'Trial number out of range, must be [1,20], is [{},{}]'.format(\\n min(trial), max(trial))\\n\\n cols = self._get_data(gas, loc, voltage, speed, trial)\\n return cols\",\n \"def __init__(self):\\n \\n # Call the super contructor\\n super(Select, self).__init__(0, 0, 200, 50)\\n\\n # Assign personalisation attributes\\n self.placeholder = \\\"Choose a value\\\"\\n self.font_name: str = None\\n self.font_size: int = 12\\n\\n self.bg_color: tuple = (0, 0, 0, 0)\\n self.bg_hover: tuple = (255, 255, 255, 30)\\n self.bg_press: tuple = None\\n\\n self.label_color: tuple = (255, 255, 255, 255)\\n self.label_hover: tuple = None\\n self.label_press: tuple = None\\n\\n self.border_color: tuple = (255, 255, 255, 255)\\n self.border_hover: tuple = None\\n self.border_press: tuple = None\\n self.border_width: int = 4\\n\\n self.option_height: int = 45\\n self.option_margin: int = 5\\n self.option_font_name = None\\n self.option_font_size = 12\\n\\n self.option_bg_color: tuple = (0, 0, 0, 0)\\n self.option_bg_hover: tuple = (255, 255, 255, 30)\\n self.option_bg_press: tuple = None\\n self.option_bg_select: tuple = (255, 255, 255, 60)\\n\\n self.option_label_color: tuple = (255, 255, 255, 255)\\n self.option_label_hover: tuple = None\\n self.option_label_press: tuple = None\\n self.option_label_select: tuple = None\\n\\n # Assign internal attributes\\n self._is_hovered: bool = False\\n self._is_pressed: bool = False\\n self._is_opened: bool = False\\n self._is_inverted: bool = False\\n self._options: list = list()\\n self._current_select: int = -1\\n self._current_hover: int = -1\\n\\n self._bg = pyglet.shapes.Rectangle\\n self._label = pyglet.text.Label\\n self._border = Border\\n\\n self._option_border: Border = None\\n self._options_bg: list = list()\\n self._options_label: list = list()\",\n \"def __init__(self, hgtStartData):\\r\\n self.data = []\\r\\n for row in hgtStartData:\\r\\n toAdd = []\\r\\n for height in row:\\r\\n toAdd.append([height, 0])\\r\\n self.data.append(toAdd)\\r\\n self.maxX = len(hgtStartData[0]) - 1\\r\\n self.maxY = len(hgtStartData) - 1\\r\\n\\r\\n self.minFloodHeight = 0\",\n \"def create_interval_hsb(confidence, n_samples, data_point):\\n if n_samples == 0:\\n return Interval(0, 1)\\n delta = margin_hsb(confidence, n_samples, data_point)\\n return Interval(float(max(data_point - delta, 0)), float(min(data_point + delta, 1)))\",\n \"def element(selection, sel_type='id'):\\n selector = get_selector_method(sel_type)\\n return selector(selection)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5978266","0.5615562","0.53860027","0.53363514","0.52604216","0.5230591","0.5123659","0.5109732","0.5086925","0.50513536","0.50479877","0.5033334","0.49208","0.49170148","0.4872133","0.4828051","0.48176673","0.47932035","0.4729161","0.4611828","0.4548788","0.45258135","0.45256746","0.4518496","0.45113194","0.45038095","0.44976357","0.4467496","0.4460264","0.4458065","0.445146","0.44489405","0.44391263","0.4399108","0.43989527","0.43842357","0.42949075","0.42814448","0.4278862","0.4273409","0.42652312","0.42446917","0.4239347","0.42383683","0.42346287","0.42314786","0.42274785","0.42203844","0.420049","0.41954997","0.41747656","0.4171289","0.41667187","0.41656277","0.41603115","0.41472495","0.41453823","0.41398874","0.4138515","0.41288197","0.41205293","0.41195765","0.41177705","0.41177705","0.41170934","0.41142002","0.41080582","0.41022882","0.40951672","0.40948918","0.408553","0.40842402","0.4082453","0.40815133","0.4077606","0.40774184","0.40744117","0.40719038","0.40692466","0.40666434","0.40657264","0.40646943","0.4057667","0.40538895","0.4043869","0.40420336","0.40403202","0.4028882","0.4015297","0.40142134","0.40113807","0.40112755","0.40112755","0.40041262","0.40039748","0.4002402","0.40021467","0.39998695","0.39994878","0.39925647"],"string":"[\n \"0.5978266\",\n \"0.5615562\",\n \"0.53860027\",\n \"0.53363514\",\n \"0.52604216\",\n \"0.5230591\",\n \"0.5123659\",\n \"0.5109732\",\n \"0.5086925\",\n \"0.50513536\",\n \"0.50479877\",\n \"0.5033334\",\n \"0.49208\",\n \"0.49170148\",\n \"0.4872133\",\n \"0.4828051\",\n \"0.48176673\",\n \"0.47932035\",\n \"0.4729161\",\n \"0.4611828\",\n \"0.4548788\",\n \"0.45258135\",\n \"0.45256746\",\n \"0.4518496\",\n \"0.45113194\",\n \"0.45038095\",\n \"0.44976357\",\n \"0.4467496\",\n \"0.4460264\",\n \"0.4458065\",\n \"0.445146\",\n \"0.44489405\",\n \"0.44391263\",\n \"0.4399108\",\n \"0.43989527\",\n \"0.43842357\",\n \"0.42949075\",\n \"0.42814448\",\n \"0.4278862\",\n \"0.4273409\",\n \"0.42652312\",\n \"0.42446917\",\n \"0.4239347\",\n \"0.42383683\",\n \"0.42346287\",\n \"0.42314786\",\n \"0.42274785\",\n \"0.42203844\",\n \"0.420049\",\n \"0.41954997\",\n \"0.41747656\",\n \"0.4171289\",\n \"0.41667187\",\n \"0.41656277\",\n \"0.41603115\",\n \"0.41472495\",\n \"0.41453823\",\n \"0.41398874\",\n \"0.4138515\",\n \"0.41288197\",\n \"0.41205293\",\n \"0.41195765\",\n \"0.41177705\",\n \"0.41177705\",\n \"0.41170934\",\n \"0.41142002\",\n \"0.41080582\",\n \"0.41022882\",\n \"0.40951672\",\n \"0.40948918\",\n \"0.408553\",\n \"0.40842402\",\n \"0.4082453\",\n \"0.40815133\",\n \"0.4077606\",\n \"0.40774184\",\n \"0.40744117\",\n \"0.40719038\",\n \"0.40692466\",\n \"0.40666434\",\n \"0.40657264\",\n \"0.40646943\",\n \"0.4057667\",\n \"0.40538895\",\n \"0.4043869\",\n \"0.40420336\",\n \"0.40403202\",\n \"0.4028882\",\n \"0.4015297\",\n \"0.40142134\",\n \"0.40113807\",\n \"0.40112755\",\n \"0.40112755\",\n \"0.40041262\",\n \"0.40039748\",\n \"0.4002402\",\n \"0.40021467\",\n \"0.39998695\",\n \"0.39994878\",\n \"0.39925647\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.40723988"},"document_rank":{"kind":"string","value":"77"}}},{"rowIdx":7393,"cells":{"query":{"kind":"string","value":"Create and return a D > D0 pi Selection object."},"document":{"kind":"string","value":"def makeDstar2D0Pi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\n #\n ## check existing selection\n #\n sel = self._selection ( sel_tag )\n if sel : return sel \n\n #\n ## adjust a bit the arguments\n if not kwargs.has_key('Preambulo') :\n kwargs ['Preambulo' ] = self['Preambulo']\n\n if not kwargs.has_key( 'ParticleCombiners' ) :\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \n \n # \n ## use \"simple-selection\"\n #\n from PhysSelPython.Wrappers import SimpleSelection\n sel = SimpleSelection (\n sel_name ,\n algotype ,\n inputs , \n *args ,\n **kwargs )\n # \n return self._add_selection( sel_tag , sel )","def from_selection(cls):\n guid = compas_rhino.select_point()\n return cls.from_guid(guid)","def create(cls, selection):\n\t\t\n\t\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })","def from_selection(\n class_,\n selection,\n item_class=None,\n ):\n import abjad\n pitch_segment = abjad.PitchSegment.from_selection(selection)\n return class_(\n pitch_segment,\n item_class=item_class,\n )","def makeDefault(name,inputSel) :\n from Configurables import OfflineVertexFitter\n Detached4mu = CombineParticles(\"Combine\"+name)\n Detached4mu.DecayDescriptor = \"B_s0 -> mu+ mu- mu+ mu-\"\n # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:\n Detached4mu.addTool( OfflineVertexFitter )\n Detached4mu.ParticleCombiners.update( { \"\" : \"OfflineVertexFitter\"} )\n Detached4mu.OfflineVertexFitter.useResonanceVertex = False\n Detached4mu.ReFitPVs = True\n Detached4mu.DaughtersCuts = { \"mu+\" : \"(TRCHI2DOF < 2.5 ) \"\\\n \" & (MIPCHI2DV(PRIMARY)> 9.)\"}\n \n Detached4mu.CombinationCut = \"(ADAMASS('B_s0')<1000*MeV) \"\\\n \"& (AMAXDOCA('')<0.3*mm)\"\n Detached4mu.MotherCut = \"(VFASPF(VCHI2/VDOF)<9) \"\\\n \"& (BPVDIRA > 0) \"\\\n \"& (BPVVDCHI2>100)\"\\\n \" & (M>4366.3) & (M<6366.3)\"\\\n \"& (BPVIPCHI2()< 25) \"\n \n\n return Selection (name,\n Algorithm = Detached4mu,\n RequiredSelections = inputSel)","def make_odorant_selector(name):\n return dcc.Input(\n id=\"cid_%s\" % name,\n placeholder=\"Enter a PubChem ID number...\",\n type=\"number\",\n value=None,\n )","def makePseudoPsi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n _daugCuts = \"(PT> %(D0PtLoose)s*MeV)\" % locals()['config']\n _combCuts = \"(APT> %(D0PtLoose)s*MeV)\" % locals()['config']\n\n _Psi = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"D0\": _daugCuts }\n , CombinationCut = _combCuts\n , MotherCut = \"(VFASPF(VCHI2PDOF) < 10000)\"\n )\n\n return Selection( name+'Sel',\n Algorithm = _Psi,\n RequiredSelections = inputSel\n )","def createSelector(self,type='select',speed=2.0):\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector.hide()\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def __init__(self,initial_v,v_select=0,max_dev_semitones=1):\n self.v=initial_v\n self.v_select=v_select\n self.max_dev_semitones=max_dev_semitones","def __init__(self):\n super().__init__()\n self.p = 0.0\n self.type = 'Geometric'\n self.distType = 'Discrete'\n self.lowerBound = 0.0\n self.upperBound = 1.0\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def __init__(self, pvID, pvP, pvQ, pvDescriptor):\n\n # TODO: implement this","def makeDstarPartial( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )","def from_selection(cls):\n guid = compas_rhino.select_mesh()\n return cls.from_guid(guid)","def createSelector2(self,type='select',speed=2.0):\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector2.hide()\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def __init__(self):\n super().__init__()\n self.p = 0.0\n self.type = 'Bernoulli'\n self.distType = 'Discrete'\n self.lowerBound = 0.0\n self.upperBound = 1.0\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def __init__(self, P, I, D, dt):\n\n\t\tself._Kp = P\n\t\tself._Ki = I\n\t\tself._Kd = D\n\t\tself._dt = dt","def curve_through_selection(*args):\n sel = cmds.ls(sl=True, fl=True)\n if not sel or len(sel)==1:\n cmds.warning(\"You need to select multiple things to create curve through!\")\n return()\n\n pList = []\n crvType = cmds.radioButtonGrp(widgets[\"crvSelRBG\"], q=True, sl=True)\n\n for obj in sel:\n if cmds.objectType(obj) in [\"transform\"]:\n pos = cmds.xform(obj, q=True, ws=True, rp=True)\n pList.append(pos)\n elif obj in cmds.filterExpand(sm=[28, 30, 31, 32, 34, 46]):\n pos = cmds.pointPosition(obj)\n pList.append(pos)\n\n #add points if only 2 (cv, ep) or 3 (cv) are given, and create the curve\n if crvType == 1:\n if len(pList) == 2:\n f = [float(sum(x)/2) for x in zip(*pList)]\n pList.insert(1, f)\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\n pList.insert(1, newPt1)\n pList.insert(3, newPt2)\n if len(pList) == 3:\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\n pList.insert(1, newPt1)\n pList.insert(3, newPt2)\n crv = cmds.curve(d=3, p=pList, name=\"newCurve\")\n\n if crvType == 2:\n if len(pList) == 2:\n f = [float(sum(x)/2) for x in zip(*pList)]\n pList.insert(1, f)\n crv = cmds.curve(d=3, ep=pList, name=\"newCurve\")\n\n return(crv)","def __init__(\n self, name: str, values: List[Dict], index: Optional[int] = 0,\n label: Optional[str] = None, help: Optional[str] = None,\n default: Optional[bool] = None, required: Optional[bool] = False,\n group: Optional[str] = None\n ):\n super(Select, self).__init__(\n dtype=PARA_SELECT,\n name=name,\n index=index,\n label=label,\n help=help,\n default=default,\n required=required,\n group=group\n )\n self.values = values","def build_selection_spec(client_factory, name):\r\n sel_spec = client_factory.create('ns0:SelectionSpec')\r\n sel_spec.name = name\r\n return sel_spec","def __init__(self):\n super().__init__()\n self.n = 0.0\n self.p = 0.0\n self.type = 'Binomial'\n self.hasInfiniteBound = True\n self.distType = 'Discrete'\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def pdos_select(self, atoms=None, spin=None, l=None, m=None):\n valid_m_values = {'s': [],\n 'p': ['x', 'y', 'z'],\n 'd': ['xy', 'yz', 'z2-r2', 'xz', 'x2-y2'],\n 'f': ['y(3x2-y2)', 'xyz', 'yz2', 'z3', 'xz2', 'z(x2-y2)', 'x(x2-3y2)']}\n if not atoms:\n atom_idx = list(range(self.number_of_atoms))\n else:\n atom_idx = atoms\n to_return = self.pdos_raw[atom_idx, :, :, :]\n if not spin:\n spin_idx = list(range(self.ispin))\n elif spin == 'up':\n spin_idx = [0]\n elif spin == 'down':\n spin_idx = [1]\n elif spin == 'both':\n spin_idx = [0, 1]\n else:\n raise ValueError\n to_return = to_return[:, :, :, spin_idx]\n\n if not l:\n channel_idx = list(range(self.number_of_channels))\n elif l == 's':\n channel_idx = [0]\n elif l == 'p':\n if not m:\n channel_idx = [1, 2, 3]\n else:\n channel_idx = [1 + i for i, v in enumerate(valid_m_values['p']) if v in m]\n elif l == 'd':\n if not m:\n channel_idx = [4, 5, 6, 7, 8]\n else:\n channel_idx = [4 + i for i, v in enumerate(valid_m_values['d']) if v in m]\n elif l == 'f':\n if not m:\n channel_idx = [9, 10, 11, 12, 13, 14, 15]\n else:\n channel_idx = [9 + i for i, v in enumerate(valid_m_values['f']) if v in m]\n else:\n raise ValueError\n\n return to_return[:, :, channel_idx, :]","def select(self):\n\t\tbest_num_components = self.n_constant\n\t\treturn self.base_model(best_num_components)","def __init__(self, parent):\n # parent is the main frame of PyCorrFit\n self.parent = parent\n ## MYID\n # This ID is given by the parent for an instance of this class\n self.MyID = None\n ## Wrapping\n curvedict, labels = self.GetCurvedict()\n self.labels = labels\n self.Selector = UserSelectCurves(parent, curvedict,\n wrapper=self, labels=labels)\n # This is necessary for parent to deselect and select the tool\n # in the tools menu.\n self.Bind = self.Selector.Bind\n if self.parent.notebook.GetPageCount() == 0:\n self.Selector.sp.Disable()","def __init__(self, p) -> None:\n self._p = p\n self._delegate = TwoQubitAsymmetricDepolarizingChannel(p / 15, p / 15, p / 15,\n p / 15, p / 15, p / 15,\n p / 15, p / 15, p / 15,\n p / 15, p / 15, p / 15,\n p / 15, p / 15, p / 15)","def _an_element_(self):\n from sage.rings.integer_ring import ZZ\n return self(self.realization_of().PD().get_point(ZZ.zero()))","def 选择项目(self, n): # real signature unknown; restored from __doc__\n return self.Select(n)","def generate_kdtree(self):\n if self.method==2:\n coordinates = self.unassigned_data[0:3,:]\n else:\n coordinates = self.unassigned_data[0:2,:]\n tree = cKDTree(coordinates.T)\n\n return tree","def _select_single(self, disc):\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)","def __init__(self, r=1, p=3):\n self.p = p\n self.r = r","def make_selection(self, num):\n other_doors = None\n if num is 1:\n other_doors = [str(2), str(3)]\n elif num is 2:\n other_doors = [str(1), str(3)]\n elif num is 3:\n other_doors = [str(1), str(2)]\n\n reveal = str(random.choice(other_doors))\n other_doors.remove(reveal)\n third_door = random.choice(other_doors)\n other_doors.remove(third_door)\n\n main_door = getattr(self, 'door' + str(num) + '_counter')\n door_second = getattr(self, 'door' + reveal + '_counter')\n door_third = getattr(self, 'door' + third_door + '_counter')\n main_door_reveal = getattr(self, 'door'+str(num)+'_reveal')\n\n if (main_door is 0 and door_second is 0\n and door_third is 0):\n self.ids['door'+reveal].source = \\\n getattr(self, 'door'+reveal+'_reveal')\n self.ids['button'+reveal].disabled = True\n inc = getattr(self, 'door' + str(num) + '_counter')\n setattr(self, 'door' + str(num) + '_counter', inc + 1)\n elif main_door is 1 and door_second is 0 and door_third is 0:\n for i in range(1, 4, 1):\n self.ids['door' + str(i)].source = \\\n getattr(self, 'door' + str(i) + '_reveal')\n self.ids['button'+str(i)].disabled = True\n if main_door_reveal in ['door-money.png']:\n self.win_popup()\n else:\n self.lose_popup()\n elif main_door is 0 and (door_second is 1 or door_third is 1):\n for i in range(1, 4, 1):\n self.ids['door' + str(i)].source = \\\n getattr(self, 'door' + str(i) + '_reveal')\n self.ids['button'+str(i)].disabled = True\n if main_door_reveal in ['door-money.png']:\n self.win_popup()\n else:\n self.lose_popup()","def get_selection():\n\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\n sel_len = len(selected)\n result = SelectionContainer()\n\n for _x in range(0, sel_len):\n\n shape_type = selected[_x].ShapeType\n\n if shape_type == 'Vertex':\n result.vertices.append(selected[_x])\n\n elif shape_type == 'Edge':\n\n if 'Line' in str(selected[_x].Curve):\n result.lines.append(selected[_x])\n else:\n result.curves.append(selected[_x])","def __init__(self, disk_radius=None, even_sampling=False, no_data_value=None, ignore_labels=None):\n self.disk_radius = disk_radius\n self.ignore_labels = [] if ignore_labels is None else ignore_labels\n self.even_sampling = even_sampling\n self.no_data_value = no_data_value","def selection(self):\n # create an empty priority queue for the new generation\n newGeneration = PriorityQueue()\n # pick top X of the population to survive\n for c in range(0, self.generation.qsize() / SELECTION_FRACTION):\n # get a chromosome\n chromosome = self.generation.get()\n # put the chromosomes in the new generation\n newGeneration.put(chromosome)\n # keep the new generation\n self.generation = newGeneration","def initP0(self, size, radius):\n return h.circle(size, radius)[:, :, 0]","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def __init__(self, *args, **kwargs):\n _gdi_.PseudoDC_swiginit(self,_gdi_.new_PseudoDC(*args, **kwargs))","def __init__(self,min_instances=30, drift_level=3.0):\n\n from math import sqrt\n self.min_instances = min_instances\n self.drift_level = float(drift_level)\n self.i = None\n self.pi = None\n self.si = None\n self.pi_min = None\n self.si_min = None\n self.sqrt=sqrt\n self.reset()","def __init__(self):\n super().__init__()\n self.mu = 0.0\n self.type = 'Poisson'\n self.hasInfiniteBound = True\n self.distType = 'Discrete'\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def _create_example_door():\n return Door({\"warning\": False, \"closed\": True, \"locked\": False})","def construct_random_initial(self):\n x = np.random.random((self._crv_size, self._bound))\n return x","def __make_slide(self):\n # Create base rectangle for slide\n length = self.parameters['slide_base_length'] + self.parameters['bearing_slide_travel']\n width = self.parameters['slide_width']\n height = self.parameters['slide_height']\n slide = fso.Box(x=length,y=width,z=height)\n # Create the mounting holes\n radius = 0.5*self.parameters['slide_screw_size']\n base_hole = fso.Cylinder(r=radius, l=2*height)\n hole_list = []\n for i in (-1,1):\n for j in (-1,1):\n xpos = i*(0.5*length - self.parameters['slide_screw_inset'])\n ypos = j*(0.5*self.parameters['slide_screw_dW'])\n hole = base_hole.copy()\n hole.translate([xpos,ypos,0])\n hole_list.append(hole)\n # Remove hole material\n slide -= hole_list\n slide.set_color(self.slide_color,recursive=True)\n self.slide = slide","def pool_selected( self, object ):\n\t\tud.debug( ud.ADMIN, ud.INFO, 'UVMM.DW.ps(node_uri=%s)' % self.node_uri)\n\t\tpool_name = object.options.get('pool-name')\n\t\tif not pool_name:\n\t\t\tpool_name = object.options['pool-name'] = 'default'\n\t\tdrive_type = object.options['drive-type']\n\t\ttry:\n\t\t\tif drive_type == 'cdrom':\n\t\t\t\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'cdrom')\n\t\t\telse:\n\t\t\t\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'disk' )\n\t\texcept uvmmd.UvmmError, e:\n\t\t\tvols = ()\n\t\tud.debug(ud.ADMIN, ud.INFO, 'UVMM.DW.ps: volumes=%s' % map(str, vols))\n\t\tchoices = []\n\t\tfor vol in vols:\n\t\t\tbasename = os.path.basename( vol.source )\n\t\t\tif '.' in basename:\n\t\t\t\tsuffix = basename[ basename.rfind( '.' ) + 1 : ]\n\t\t\t\tif suffix in ( 'xml', 'snapshot' ):\n\t\t\t\t\tcontinue\n\t\t\tchoices.append( basename )\n\t\tchoices.sort()\n\t\tself.image_syntax.update_choices( choices )\n\n\t\t# recreate pool button\n\t\tbtn = self._create_pool_select_button( object.options )\n\t\tself[DriveWizard.PAGE_OLD].options[0] = btn\n\t\tself[DriveWizard.PAGE_NEW].options[0] = btn\n\t\t# recreate driver-type button\n\t\titems = [self[DriveWizard.PAGE_NEW].options[2].id(), self[DriveWizard.PAGE_NEW].options[3].id()]\n\t\tbtn = self._create_type_select_button(object.options, items)\n\t\tself[DriveWizard.PAGE_NEW].options[1] = btn\n\n\t\tif drive_type == 'disk':\n\t\t\tself[DriveWizard.PAGE_OLD].hint = None\n\t\telif drive_type in ( 'cdrom', 'floppy' ):\n\t\t\tif self.image_syntax._choices:\n\t\t\t\tmsg = _( \"If the required image is not found it might be added by copying the file into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\" )\n\t\t\telse:\n\t\t\t\tmsg = _( \"The list of available images is empty! To add an image the file needs to be copied into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\" )\n\t\t\tself[DriveWizard.PAGE_OLD].hint = msg\n\t\t\tself[DriveWizard.PAGE_OLD].description = ''\n\t\telse:\n\t\t\traise ValueError('Invalid drive-type \"%s\"' % drive_type)\n\n\t\treturn self.type_selected(object)","def selection(self):\n if not self._selection:\n return None\n \n year, month = self._date.year, self._date.month\n return self.datetime(year, month, int(self._selection[0]))","def __init__(self, r1=4.5*0.0254, r2=4.5*0.0254,\n d1=25.0*0.0254, d2=25.0*0.0254,\n Ixx=185000.0*0.45359237*0.0254**2,\n Iyy=185000.0*0.45359237*0.0254**2,\n Izz=3500.0*0.45359237*0.0254**2,):\n self.r1 = r1 # m\n self.r2 = r2 # m\n self.d1 = d1 # m\n self.d2 = d2 # m\n self.Ixx = Ixx # kg-m^2\n self.Iyy = Iyy # kg-m^2\n self.Izz = Izz # kg-m^2","def _generate_solution(self):\n \n operation_list = []\n available = {job.get_job_id(): [operation for operation in job.get_operations() if operation.get_sequence() == 0] for job in self.jssp_instance_data.jobs} # dictionary of first unprocessed operations of each job\n \n while 0 < len(available):\n rand_job_id = random.choice(list(available.keys()))\n rand_operation = random.choice(available[rand_job_id])\n rand_machine = np.random.choice(rand_operation.get_required_machines())\n\n available[rand_job_id].remove(rand_operation)\n \n if len(available[rand_job_id]) == 0:\n # if selected operation is last operation of the job \n if rand_operation.get_sequence() == self.jssp_instance_data.get_job(rand_job_id).get_max_sequence():\n del available[rand_job_id]\n else:\n available[rand_job_id] = [t for t in self.jssp_instance_data.get_job(rand_job_id).get_operations() if\n t.get_sequence() == rand_operation.get_sequence() + 1]\n\n\n operation_list.append([rand_job_id, rand_operation.get_operation_id(), rand_operation.get_sequence(), rand_machine]) # chromosome representation \n return Solution(self.jssp_instance_data, np.array(operation_list, dtype=np.intc))","def __init__(self, dict = {}):\r\n if dict == {}:\r\n self.zero_val()\r\n else:\r\n self.piDD = dict\r\n self.top_node = utilities.max_length_in_list(self.return_keys())\r\n if self.piDD[self.top_node] == None:\r\n self.dim = 0\r\n else:\r\n self.dim = self.piDD[self.top_node][0][0]","def __init__(self):\n\n self.P = list()\n self.label = 0","def __init__(self, radius=0.5, extra={}):\n self.radius = radius\n self.sensors = [] # array of Attached\n self.id_sensors = None\n self.id_dynamics = None # XXX\n self.dynamics = None\n self.extra = extra\n\n self.primitives = set()\n\n # Needs to be initialized before calling certain functions\n self._state = None","def _select(self):\n sel = []\n\n # choose randomly while favouring fit individuals\n lp = len(self.population) // 2\n for _ in range(lp):\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n while idx1 == idx2:\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n\n p1, p2 = self.population[idx1], self.population[idx2]\n sel.append((p1, p2))\n\n return sel","def eta23pi ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays\n ## \n pre_eta = self.make_selection (\n ## the unique tag \n 'PreEta3Pi' ,\n ## algorithm type to be used\n DaVinci__N3BodyDecays ,\n ## input selections \n [ self.pions () , self.pi0 () ] ,\n ## algorithm properties \n DecayDescriptor = \" eta -> pi+ pi- pi0\" ,\n ## \n Combination12Cut = \"\"\" ( AM < 700 * MeV ) &\n ( ACHI2DOCA(1,2) < 12 ) \n \"\"\" , \n ##\n CombinationCut = \"\"\"\n ( APT > %s ) & ( ADAMASS ( 'eta' ) < 100 * MeV )\n \"\"\" % ( 0.9 * self['ETA_PT'] ) ,\n ##\n MotherCut = \"\"\"\n ( PT > %s ) &\n ( chi2vx < 9 ) \n \"\"\" % self['ETA_PT']\n )\n ##\n from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger2g\n ## \n return self.make_selection (\n 'Eta23pi' ,\n Pi0Veto__Tagger2g ,\n [ pre_eta ] ,\n MassWindow = 25 * MeV ,\n MassChi2 = -1 ,\n ExtraInfoIndex = 25016 ## unique ! \n )","def __init__(self):\n raise NotImplementedError('cannot create independent arc')","def __init__(self, d):\n\t\tself._coords = [0] * d","def test_non_it(self):\n self.idx = [9, 11, 6, 10, 12, 2, 8, 1, 5, 0, 7, 4, 3]\n selector = PCovCUR(n_to_select=12, iterative=False)\n selector.fit(self.X, self.y)\n\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))","def __init__(self):\n\n # Assign a nullptr for the device-side pointers. These will be set if the GPU is utilized.\n self.ng = int(0)\n self.goals = ct.POINTER(ct.c_uint)()\n self.currentHorizon = int(0)\n self.V = ct.POINTER(ct.c_float)()\n self.VPrime = ct.POINTER(ct.c_float)()\n self.pi = ct.POINTER(ct.c_uint)()\n self.ne = int(0)\n self.expanded = ct.POINTER(ct.c_int)()\n self.d_goals = ct.POINTER(ct.c_uint)()\n self.d_S = ct.POINTER(ct.c_int)()\n self.d_T = ct.POINTER(ct.c_float)()\n self.d_R = ct.POINTER(ct.c_float)()\n self.d_V = ct.POINTER(ct.c_float)()\n self.d_VPrime = ct.POINTER(ct.c_float)()\n self.d_pi = ct.POINTER(ct.c_uint)()\n self.d_expanded = ct.POINTER(ct.c_int)()\n\n # Additional informative variables.\n self.Rmin = None\n self.Rmax = None","def selected_choice(self):\r\n choice = zeros(self.num_agents)\r\n random_numbers = self.generate_random_numbers()\r\n\r\n self.prob_cumsum = self.cumprob().filled(-1)\r\n\r\n for i in range(self.num_choices):\r\n # Indicator for the zero cells in the choice array\r\n #indicator_zero_cells = ones(self.num_agents)\r\n indicator = array([True]*self.num_agents)\r\n\r\n zero_indices = choice == 0\r\n #indicator_zero_cells[~zero_indices] = ma.masked\r\n indicator[~zero_indices] = False\r\n\r\n # Indicator for the cells where the random number\r\n # is less than the probability\r\n #indicator_less_cells = ones(self.num_agents)\r\n #indicator_less_cells = array([True]*self.num_agents)\r\n less_indices = random_numbers < self.prob_cumsum[:,i]\r\n #indicator_less_cells[~less_indices] = ma.masked\r\n #indicator_less_cells\r\n indicator[~less_indices] = False\r\n\r\n\r\n #indicator_less_zero_cells = indicator_zero_cells + indicator_less_cells\r\n\r\n #indicator_less_zero_cells = indicator_less_zero_cells == 2\r\n\r\n choice[indicator] = i + 1\r\n\r\n choice.shape = (self.num_agents, 1)\r\n\r\n #alt_text = []\r\n #for i in choice:\r\n # alt_text.append(self.choices[int(i[0])-1])\r\n #alt_text = array(alt_text)\r\n #alt_text.shape = (self.num_agents, 1)\r\n\r\n #return alt_text\r\n #print choice\r\n return DataArray(choice, ['selected choice'])","def __init__(self, analogue_selection='indep', clock_selection='in', cal_mode='no_cal', clk_speed=800):\n self.value = 0\n self.value |= (0b1 << 2) # disable chip version output bit\n self.value |= (0b1 << 3) # set demux to 1:2\n clk_bits = 0b00 if (clk_speed<125) else 0b01 if (clk_speed<250) else 0b10 if (clk_speed<500) else 0b11\n self.value |= (clk_bits << 12) # control wait bit calibration value is dependent on clk speed\n self.value |= (1 << 14) # set FDataReady to Fs/2. I don't know what this means\n self.set_analogue_selection(analogue_selection)\n self.set_clock_selection(clock_selection)\n self.set_cal_mode(cal_mode)","def pi(self):\n return self(self._real_field().pi())","def __init__(self):\n super().__init__()\n self.lambdaVar = 1.0\n self.low = 0.0\n self.type = 'Exponential'\n self.distType = 'Continuous'\n self.hasInfiniteBound = True\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def __init__(self, params):\r\n _params = {'Similarity': 0.97,\r\n 'Application': 'cdhit',\r\n 'Algorithm': 'cdhit: \"longest-sequence-first list removal algorithm\"'}\r\n _params.update(params)\r\n OtuPicker.__init__(self, _params)","def __init__(self, goal=0, kP=1, kI=1, kD=1, init_pt=0):\n self._pid_lock = threading.Lock()\n\n self.set_goal(goal)\n self.reset(init_pt)\n self.set_gains({\n PIDController.KP_KEY: kP,\n PIDController.KI_KEY: kI,\n PIDController.KD_KEY: kD\n })","def select(self):\n\n return self.p[0], self.p[1]","def __init__(\n self, voltage={0:(0, 0)}, rate=500, repetitions=1,\n board_name='cDAQ1Mod1', voltage_limits=None, num_channels=7):\n self.board_name = board_name #Check Measurement and Automation Explorer\n self._taskHandle = ctypes.c_void_p(0)\n self.num_channels = num_channels\n DAQmxErrChk(api.DAQmxCreateTask(\"\", ctypes.byref(self._taskHandle)))\n DAQmxErrChk(api.DAQmxCreateAOVoltageChan(\n self._taskHandle,\n self.board_name + \"/ao0:%i\"%(num_channels - 1),\n \"\",\n ctypes.c_double(-10.0), #Minimum voltage\n ctypes.c_double(10.0), #Maximum voltage\n 10348, #DAQmx_Val_Volts; don't question it!\n ctypes.c_void_p(0), #NULL\n ))\n self.num_points_written = ctypes.c_long(0)\n self._unwritten_voltages = False\n self._unplayed_voltages = False\n self.set_voltage_and_timing(voltage, rate, repetitions, voltage_limits)\n return None","def get_selection(self, selection_name, format=None):","def null(cls, d=2):\n return cls(*[0 for i in range(d)])","def circle(self):\n return circle(self.N, self.o, self.r)","def p_selection(p_init, it, n_iters):\n it = int(it / n_iters * 10000)\n\n if 10 < it <= 50:\n p = p_init / 2\n elif 50 < it <= 200:\n p = p_init / 4\n elif 200 < it <= 500:\n p = p_init / 8\n elif 500 < it <= 1000:\n p = p_init / 16\n elif 1000 < it <= 2000:\n p = p_init / 32\n elif 2000 < it <= 4000:\n p = p_init / 64\n elif 4000 < it <= 6000:\n p = p_init / 128\n elif 6000 < it <= 8000:\n p = p_init / 256\n elif 8000 < it <= 10000:\n p = p_init / 512\n else:\n p = p_init\n\n return p","def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\n self.GP = GPIOProcessor()\n self.pin1 = self.GP.getPin(pin1)\n self.pin2 = self.GP.getPin(pin2)\n self.pin3 = self.GP.getPin(pin3)\n self.pin4 = self.GP.getPin(pin4)\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\n\n for k in range(4):\n self.pinl[k].out()\n\n self.speed = 100.0","def select_arm(self):\n\n # Exploitation\n if random.uniform(0, 1) > self.epsilon:\n return np.argmax(self.values)\n\n # Exploration\n else:\n return random.randrange(len(self.values))","def pick(self):\n\n pickerdict = {}\n current_value = 0\n\n if len(self.choices) == 0:\n return None\n\n if len(self.choices) == 1:\n return self.choices[0][0]\n\n for option in self.choices:\n pickerdict[current_value] = option[0]\n current_value += option[1]\n\n picker = random.randint(0, current_value)\n last_value = 0\n result = None\n sorted_keys = sorted(pickerdict.keys())\n\n found = False\n for key in sorted_keys:\n if key >= picker:\n result = pickerdict[last_value]\n found = True\n continue\n last_value = key\n\n if not found:\n result = pickerdict[sorted_keys[-1]]\n\n return result","def select(self):\n pass","def select(self):\n pass","def __init__(self, choice):\r\n self.choice = choice","def make_car():\n car = Car() \n car.drop_val = random.randint(0,1)\n\n if car.drop_val == 0:\n car.drop_x = random.randint(77, 400) * 2\n\n elif car.drop_val == 1:\n car.drop_y = random.randint(62, 300) *2\n\n return car","def __init__(self, D, K):\n\t\tself.D = D \n\t\tself.K = K \n\t\tself.V = np.zeros((D+1,K))\n\t\treturn","def dropdown(self):\n # defaults = DDConfig(0.6, 0.6, 0, 0)\n return DropDown(self.name, self.command, **self.config)","def touching_choice(self,p):\n\n part = ['head', 'foot1', 'foot2', 'foot3', 'foot4', 'back', 'stomach', 'tail']\n if len(self.select[p]) == 0:\n return random.sample(part,2)\n elif len(self.select[p]) == 1:\n part.remove(self.select[p][0])\n c = random.sample(part,1)\n return [self.select[p][0], c[0]]\n else:\n return random.sample(self.select[p],2)","def __init__(self, inplace=False):\n super(SELU, self).__init__()\n self.inplace = inplace","def __init__(self, motor, OD_range=None, motor_range=None,\n motor_min=None, OD_min=None, motor_max=None, OD_max=None):\n self.motor = motor\n if OD_range is not None:\n self.OD_range = OD_range\n if motor_range is not None:\n self.motor_range = motor_range\n\n if motor_min is not None:\n self.motor_min = motor_min\n else:\n self.motor_min = motor_range[0]\n\n if motor_max is not None:\n self.motor_max = motor_max\n else:\n self.motor_max = motor_range[1]\n\n if OD_min is not None:\n self.OD_min = OD_min\n else:\n self.OD_min = OD_range[0]\n\n if OD_max is not None:\n self.OD_max = OD_max\n else:\n self.OD_max = OD_range[1]","def select(self):\r\n pass","def __init__(self, r: float, i: float = 0):\n self.r = r\n self.i = i","def __init__(self, tpose, mpose, tselect=[], mselect=[]):\n self.target = tpose\n self.mobile = mpose\n self.target_residues = res_selector_to_size_list(tselect)\n self.mobile_residues = res_selector_to_size_list(mselect)\n self.set_target_sequence()\n self.set_mobile_sequence()\n self.atoms = ['N','C','CA']\n self.bb_rmsd = None","def create_soft_cluster():\n # node, index_component, inf_val = general.get_soft_selection()\n soft_element_data = general.get_soft_selection()\n selection = [vtx_component for vtx_component, inf_val in soft_element_data]\n\n pm.select(selection, r=True)\n cluster = pm.cluster(relative=True)\n\n for vtx_component, inf_val in soft_element_data:\n pm.percent(cluster[0], vtx_component, v=inf_val)\n pm.select(cluster[1], r=True)\n\n return cluster","def __init__(self):\n {}\n #generate a monoid Q\n self.monoid_Q = self.generateQ()[0]\n self.relationOfElements_Q = self.generateQ()[1]\n self.p_Position = self.generateQ()[2]\n self.qOfPosition = self.generateQ()[3]\n #print(self.qOfPosition)","def get_slider():\n return dcc.RangeSlider(\n id='hours',\n value=[0, 23],\n min=0,\n max=23,\n marks={i: str(i) for i in range(0, 24, 3)}\n )","def choose_pos(self):\n s = self\n\n availablepos = []\n for dblock in s.pjs.dblocks:\n is_available = True\n\n for powerup in s.pjs.powerups:\n if powerup.rects[0].overlap(dblock.rects[0]):\n is_available = False\n break\n\n if is_available:\n availablepos.append(dblock.rpos)\n\n pos = random.randint(0, len(availablepos) - 1)\n s.rpos = availablepos[pos]","def zero_val(self):\r\n self.piDD = {\"[0]\": None}\r\n self.top_node = \"[0]\"\r\n self.dim = 0","def __init__(self):\n super().__init__()\n self.low = 0.0\n self.high = 1.0\n self.alpha = 0.0\n self.beta = 0.0\n self.type = 'Beta'\n self.distType = 'Continuous'\n self.hasInfiniteBound = True\n self.compatibleQuadrature.append('Jacobi')\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'Jacobi'\n self.preferredPolynomials = 'Jacobi'","def selectPointsUnderCursor(self):\n spw = self.spw\n sw = spw.windows['Sort']\n #if clear:\n # sw.uslist.clearSelection()\n # sw.nlist.clearSelection()\n x, y = self.cursorPosGL()\n sids = self.pick(x, y, pb=10, multiple=True)\n if sids is None:\n return\n #t0 = time.time()\n spw.SelectSpikes(sids, on=self.selecting)\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\n if self.selecting == True:\n sat = 0.2 # desaturate\n else: # self.selecting == False\n sat = 1 # resaturate\n self.color(sids, sat=sat)\n self.updateGL()","def selection(self) -> Chromosome:\n # each chromosome has a fitness, and the lower the fitness, the higher the probability of election\n choices_list = list(range(len(self._population)))\n weights = [1 / chromosome.get_fitness() for chromosome in self._population]\n\n index = choices(choices_list, weights=weights)[0]\n\n return self._population[index]","def create_pressure_vessel_geometry():\r\n\r\n # configure sigmoid function\r\n bounds_upper = [3, 6]\r\n h = 5\r\n w = 6\r\n\r\n sigmoid_function = lambda x: (1 / (1 + np.exp(-1 * h * x + w))) + 1\r\n\r\n sigmoid_function_reverse = lambda x: 1 / (1 + np.exp(h * x - w - 18)) + 1\r\n\r\n funcs_upper = [sigmoid_function, sigmoid_function_reverse]\r\n\r\n bounds_lower = None\r\n funcs_lower = 0\r\n\r\n x_max = 6\r\n x_min = 0\r\n resolution = 10000\r\n\r\n pressure_vessel = Geometry(x_max, x_min, resolution,\r\n bounds_upper, funcs_upper,\r\n bounds_lower, funcs_lower)\r\n\r\n return pressure_vessel","def random(cls, d=2, borns=[-1, 1], **kwargs):\n components = [random.uniform(*borns) for i in range(d)]\n return cls(*components, **kwargs)","def random(cls, d=2, borns=[-1, 1], **kwargs):\n components = [random.uniform(*borns) for i in range(d)]\n return cls(*components, **kwargs)"],"string":"[\n \"def make_selection ( self ,\\n tag , \\n algotype ,\\n inputs , \\n *args ,\\n **kwargs ) :\\n sel_tag = '%s_Selection' % tag\\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\\n #\\n ## check existing selection\\n #\\n sel = self._selection ( sel_tag )\\n if sel : return sel \\n\\n #\\n ## adjust a bit the arguments\\n if not kwargs.has_key('Preambulo') :\\n kwargs ['Preambulo' ] = self['Preambulo']\\n\\n if not kwargs.has_key( 'ParticleCombiners' ) :\\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \\n \\n # \\n ## use \\\"simple-selection\\\"\\n #\\n from PhysSelPython.Wrappers import SimpleSelection\\n sel = SimpleSelection (\\n sel_name ,\\n algotype ,\\n inputs , \\n *args ,\\n **kwargs )\\n # \\n return self._add_selection( sel_tag , sel )\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_point()\\n return cls.from_guid(guid)\",\n \"def create(cls, selection):\\n\\t\\t\\n\\t\\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })\",\n \"def from_selection(\\n class_,\\n selection,\\n item_class=None,\\n ):\\n import abjad\\n pitch_segment = abjad.PitchSegment.from_selection(selection)\\n return class_(\\n pitch_segment,\\n item_class=item_class,\\n )\",\n \"def makeDefault(name,inputSel) :\\n from Configurables import OfflineVertexFitter\\n Detached4mu = CombineParticles(\\\"Combine\\\"+name)\\n Detached4mu.DecayDescriptor = \\\"B_s0 -> mu+ mu- mu+ mu-\\\"\\n # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:\\n Detached4mu.addTool( OfflineVertexFitter )\\n Detached4mu.ParticleCombiners.update( { \\\"\\\" : \\\"OfflineVertexFitter\\\"} )\\n Detached4mu.OfflineVertexFitter.useResonanceVertex = False\\n Detached4mu.ReFitPVs = True\\n Detached4mu.DaughtersCuts = { \\\"mu+\\\" : \\\"(TRCHI2DOF < 2.5 ) \\\"\\\\\\n \\\" & (MIPCHI2DV(PRIMARY)> 9.)\\\"}\\n \\n Detached4mu.CombinationCut = \\\"(ADAMASS('B_s0')<1000*MeV) \\\"\\\\\\n \\\"& (AMAXDOCA('')<0.3*mm)\\\"\\n Detached4mu.MotherCut = \\\"(VFASPF(VCHI2/VDOF)<9) \\\"\\\\\\n \\\"& (BPVDIRA > 0) \\\"\\\\\\n \\\"& (BPVVDCHI2>100)\\\"\\\\\\n \\\" & (M>4366.3) & (M<6366.3)\\\"\\\\\\n \\\"& (BPVIPCHI2()< 25) \\\"\\n \\n\\n return Selection (name,\\n Algorithm = Detached4mu,\\n RequiredSelections = inputSel)\",\n \"def make_odorant_selector(name):\\n return dcc.Input(\\n id=\\\"cid_%s\\\" % name,\\n placeholder=\\\"Enter a PubChem ID number...\\\",\\n type=\\\"number\\\",\\n value=None,\\n )\",\n \"def makePseudoPsi( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n _daugCuts = \\\"(PT> %(D0PtLoose)s*MeV)\\\" % locals()['config']\\n _combCuts = \\\"(APT> %(D0PtLoose)s*MeV)\\\" % locals()['config']\\n\\n _Psi = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"D0\\\": _daugCuts }\\n , CombinationCut = _combCuts\\n , MotherCut = \\\"(VFASPF(VCHI2PDOF) < 10000)\\\"\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Psi,\\n RequiredSelections = inputSel\\n )\",\n \"def createSelector(self,type='select',speed=2.0):\\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector.hide()\\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def __init__(self,initial_v,v_select=0,max_dev_semitones=1):\\n self.v=initial_v\\n self.v_select=v_select\\n self.max_dev_semitones=max_dev_semitones\",\n \"def __init__(self):\\n super().__init__()\\n self.p = 0.0\\n self.type = 'Geometric'\\n self.distType = 'Discrete'\\n self.lowerBound = 0.0\\n self.upperBound = 1.0\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def __init__(self, pvID, pvP, pvQ, pvDescriptor):\\n\\n # TODO: implement this\",\n \"def makeDstarPartial( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n daugCuts = \\\"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\\\" % locals()['config']\\n combCuts = \\\"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\\\" % locals()['config']\\n dstarCuts = \\\"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\\\" \\\\\\n \\\"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\\\" % locals()['config']\\n\\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"pi+\\\" : daugCuts }\\n , CombinationCut = combCuts\\n , MotherCut = dstarCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dstar,\\n RequiredSelections = inputSel\\n )\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_mesh()\\n return cls.from_guid(guid)\",\n \"def createSelector2(self,type='select',speed=2.0):\\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector2.hide()\\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def __init__(self):\\n super().__init__()\\n self.p = 0.0\\n self.type = 'Bernoulli'\\n self.distType = 'Discrete'\\n self.lowerBound = 0.0\\n self.upperBound = 1.0\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def __init__(self, P, I, D, dt):\\n\\n\\t\\tself._Kp = P\\n\\t\\tself._Ki = I\\n\\t\\tself._Kd = D\\n\\t\\tself._dt = dt\",\n \"def curve_through_selection(*args):\\n sel = cmds.ls(sl=True, fl=True)\\n if not sel or len(sel)==1:\\n cmds.warning(\\\"You need to select multiple things to create curve through!\\\")\\n return()\\n\\n pList = []\\n crvType = cmds.radioButtonGrp(widgets[\\\"crvSelRBG\\\"], q=True, sl=True)\\n\\n for obj in sel:\\n if cmds.objectType(obj) in [\\\"transform\\\"]:\\n pos = cmds.xform(obj, q=True, ws=True, rp=True)\\n pList.append(pos)\\n elif obj in cmds.filterExpand(sm=[28, 30, 31, 32, 34, 46]):\\n pos = cmds.pointPosition(obj)\\n pList.append(pos)\\n\\n #add points if only 2 (cv, ep) or 3 (cv) are given, and create the curve\\n if crvType == 1:\\n if len(pList) == 2:\\n f = [float(sum(x)/2) for x in zip(*pList)]\\n pList.insert(1, f)\\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\\n pList.insert(1, newPt1)\\n pList.insert(3, newPt2)\\n if len(pList) == 3:\\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\\n pList.insert(1, newPt1)\\n pList.insert(3, newPt2)\\n crv = cmds.curve(d=3, p=pList, name=\\\"newCurve\\\")\\n\\n if crvType == 2:\\n if len(pList) == 2:\\n f = [float(sum(x)/2) for x in zip(*pList)]\\n pList.insert(1, f)\\n crv = cmds.curve(d=3, ep=pList, name=\\\"newCurve\\\")\\n\\n return(crv)\",\n \"def __init__(\\n self, name: str, values: List[Dict], index: Optional[int] = 0,\\n label: Optional[str] = None, help: Optional[str] = None,\\n default: Optional[bool] = None, required: Optional[bool] = False,\\n group: Optional[str] = None\\n ):\\n super(Select, self).__init__(\\n dtype=PARA_SELECT,\\n name=name,\\n index=index,\\n label=label,\\n help=help,\\n default=default,\\n required=required,\\n group=group\\n )\\n self.values = values\",\n \"def build_selection_spec(client_factory, name):\\r\\n sel_spec = client_factory.create('ns0:SelectionSpec')\\r\\n sel_spec.name = name\\r\\n return sel_spec\",\n \"def __init__(self):\\n super().__init__()\\n self.n = 0.0\\n self.p = 0.0\\n self.type = 'Binomial'\\n self.hasInfiniteBound = True\\n self.distType = 'Discrete'\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def pdos_select(self, atoms=None, spin=None, l=None, m=None):\\n valid_m_values = {'s': [],\\n 'p': ['x', 'y', 'z'],\\n 'd': ['xy', 'yz', 'z2-r2', 'xz', 'x2-y2'],\\n 'f': ['y(3x2-y2)', 'xyz', 'yz2', 'z3', 'xz2', 'z(x2-y2)', 'x(x2-3y2)']}\\n if not atoms:\\n atom_idx = list(range(self.number_of_atoms))\\n else:\\n atom_idx = atoms\\n to_return = self.pdos_raw[atom_idx, :, :, :]\\n if not spin:\\n spin_idx = list(range(self.ispin))\\n elif spin == 'up':\\n spin_idx = [0]\\n elif spin == 'down':\\n spin_idx = [1]\\n elif spin == 'both':\\n spin_idx = [0, 1]\\n else:\\n raise ValueError\\n to_return = to_return[:, :, :, spin_idx]\\n\\n if not l:\\n channel_idx = list(range(self.number_of_channels))\\n elif l == 's':\\n channel_idx = [0]\\n elif l == 'p':\\n if not m:\\n channel_idx = [1, 2, 3]\\n else:\\n channel_idx = [1 + i for i, v in enumerate(valid_m_values['p']) if v in m]\\n elif l == 'd':\\n if not m:\\n channel_idx = [4, 5, 6, 7, 8]\\n else:\\n channel_idx = [4 + i for i, v in enumerate(valid_m_values['d']) if v in m]\\n elif l == 'f':\\n if not m:\\n channel_idx = [9, 10, 11, 12, 13, 14, 15]\\n else:\\n channel_idx = [9 + i for i, v in enumerate(valid_m_values['f']) if v in m]\\n else:\\n raise ValueError\\n\\n return to_return[:, :, channel_idx, :]\",\n \"def select(self):\\n\\t\\tbest_num_components = self.n_constant\\n\\t\\treturn self.base_model(best_num_components)\",\n \"def __init__(self, parent):\\n # parent is the main frame of PyCorrFit\\n self.parent = parent\\n ## MYID\\n # This ID is given by the parent for an instance of this class\\n self.MyID = None\\n ## Wrapping\\n curvedict, labels = self.GetCurvedict()\\n self.labels = labels\\n self.Selector = UserSelectCurves(parent, curvedict,\\n wrapper=self, labels=labels)\\n # This is necessary for parent to deselect and select the tool\\n # in the tools menu.\\n self.Bind = self.Selector.Bind\\n if self.parent.notebook.GetPageCount() == 0:\\n self.Selector.sp.Disable()\",\n \"def __init__(self, p) -> None:\\n self._p = p\\n self._delegate = TwoQubitAsymmetricDepolarizingChannel(p / 15, p / 15, p / 15,\\n p / 15, p / 15, p / 15,\\n p / 15, p / 15, p / 15,\\n p / 15, p / 15, p / 15,\\n p / 15, p / 15, p / 15)\",\n \"def _an_element_(self):\\n from sage.rings.integer_ring import ZZ\\n return self(self.realization_of().PD().get_point(ZZ.zero()))\",\n \"def 选择项目(self, n): # real signature unknown; restored from __doc__\\n return self.Select(n)\",\n \"def generate_kdtree(self):\\n if self.method==2:\\n coordinates = self.unassigned_data[0:3,:]\\n else:\\n coordinates = self.unassigned_data[0:2,:]\\n tree = cKDTree(coordinates.T)\\n\\n return tree\",\n \"def _select_single(self, disc):\\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)\",\n \"def __init__(self, r=1, p=3):\\n self.p = p\\n self.r = r\",\n \"def make_selection(self, num):\\n other_doors = None\\n if num is 1:\\n other_doors = [str(2), str(3)]\\n elif num is 2:\\n other_doors = [str(1), str(3)]\\n elif num is 3:\\n other_doors = [str(1), str(2)]\\n\\n reveal = str(random.choice(other_doors))\\n other_doors.remove(reveal)\\n third_door = random.choice(other_doors)\\n other_doors.remove(third_door)\\n\\n main_door = getattr(self, 'door' + str(num) + '_counter')\\n door_second = getattr(self, 'door' + reveal + '_counter')\\n door_third = getattr(self, 'door' + third_door + '_counter')\\n main_door_reveal = getattr(self, 'door'+str(num)+'_reveal')\\n\\n if (main_door is 0 and door_second is 0\\n and door_third is 0):\\n self.ids['door'+reveal].source = \\\\\\n getattr(self, 'door'+reveal+'_reveal')\\n self.ids['button'+reveal].disabled = True\\n inc = getattr(self, 'door' + str(num) + '_counter')\\n setattr(self, 'door' + str(num) + '_counter', inc + 1)\\n elif main_door is 1 and door_second is 0 and door_third is 0:\\n for i in range(1, 4, 1):\\n self.ids['door' + str(i)].source = \\\\\\n getattr(self, 'door' + str(i) + '_reveal')\\n self.ids['button'+str(i)].disabled = True\\n if main_door_reveal in ['door-money.png']:\\n self.win_popup()\\n else:\\n self.lose_popup()\\n elif main_door is 0 and (door_second is 1 or door_third is 1):\\n for i in range(1, 4, 1):\\n self.ids['door' + str(i)].source = \\\\\\n getattr(self, 'door' + str(i) + '_reveal')\\n self.ids['button'+str(i)].disabled = True\\n if main_door_reveal in ['door-money.png']:\\n self.win_popup()\\n else:\\n self.lose_popup()\",\n \"def get_selection():\\n\\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\\n sel_len = len(selected)\\n result = SelectionContainer()\\n\\n for _x in range(0, sel_len):\\n\\n shape_type = selected[_x].ShapeType\\n\\n if shape_type == 'Vertex':\\n result.vertices.append(selected[_x])\\n\\n elif shape_type == 'Edge':\\n\\n if 'Line' in str(selected[_x].Curve):\\n result.lines.append(selected[_x])\\n else:\\n result.curves.append(selected[_x])\",\n \"def __init__(self, disk_radius=None, even_sampling=False, no_data_value=None, ignore_labels=None):\\n self.disk_radius = disk_radius\\n self.ignore_labels = [] if ignore_labels is None else ignore_labels\\n self.even_sampling = even_sampling\\n self.no_data_value = no_data_value\",\n \"def selection(self):\\n # create an empty priority queue for the new generation\\n newGeneration = PriorityQueue()\\n # pick top X of the population to survive\\n for c in range(0, self.generation.qsize() / SELECTION_FRACTION):\\n # get a chromosome\\n chromosome = self.generation.get()\\n # put the chromosomes in the new generation\\n newGeneration.put(chromosome)\\n # keep the new generation\\n self.generation = newGeneration\",\n \"def initP0(self, size, radius):\\n return h.circle(size, radius)[:, :, 0]\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.PseudoDC_swiginit(self,_gdi_.new_PseudoDC(*args, **kwargs))\",\n \"def __init__(self,min_instances=30, drift_level=3.0):\\n\\n from math import sqrt\\n self.min_instances = min_instances\\n self.drift_level = float(drift_level)\\n self.i = None\\n self.pi = None\\n self.si = None\\n self.pi_min = None\\n self.si_min = None\\n self.sqrt=sqrt\\n self.reset()\",\n \"def __init__(self):\\n super().__init__()\\n self.mu = 0.0\\n self.type = 'Poisson'\\n self.hasInfiniteBound = True\\n self.distType = 'Discrete'\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def _create_example_door():\\n return Door({\\\"warning\\\": False, \\\"closed\\\": True, \\\"locked\\\": False})\",\n \"def construct_random_initial(self):\\n x = np.random.random((self._crv_size, self._bound))\\n return x\",\n \"def __make_slide(self):\\n # Create base rectangle for slide\\n length = self.parameters['slide_base_length'] + self.parameters['bearing_slide_travel']\\n width = self.parameters['slide_width']\\n height = self.parameters['slide_height']\\n slide = fso.Box(x=length,y=width,z=height)\\n # Create the mounting holes\\n radius = 0.5*self.parameters['slide_screw_size']\\n base_hole = fso.Cylinder(r=radius, l=2*height)\\n hole_list = []\\n for i in (-1,1):\\n for j in (-1,1):\\n xpos = i*(0.5*length - self.parameters['slide_screw_inset'])\\n ypos = j*(0.5*self.parameters['slide_screw_dW'])\\n hole = base_hole.copy()\\n hole.translate([xpos,ypos,0])\\n hole_list.append(hole)\\n # Remove hole material\\n slide -= hole_list\\n slide.set_color(self.slide_color,recursive=True)\\n self.slide = slide\",\n \"def pool_selected( self, object ):\\n\\t\\tud.debug( ud.ADMIN, ud.INFO, 'UVMM.DW.ps(node_uri=%s)' % self.node_uri)\\n\\t\\tpool_name = object.options.get('pool-name')\\n\\t\\tif not pool_name:\\n\\t\\t\\tpool_name = object.options['pool-name'] = 'default'\\n\\t\\tdrive_type = object.options['drive-type']\\n\\t\\ttry:\\n\\t\\t\\tif drive_type == 'cdrom':\\n\\t\\t\\t\\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'cdrom')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'disk' )\\n\\t\\texcept uvmmd.UvmmError, e:\\n\\t\\t\\tvols = ()\\n\\t\\tud.debug(ud.ADMIN, ud.INFO, 'UVMM.DW.ps: volumes=%s' % map(str, vols))\\n\\t\\tchoices = []\\n\\t\\tfor vol in vols:\\n\\t\\t\\tbasename = os.path.basename( vol.source )\\n\\t\\t\\tif '.' in basename:\\n\\t\\t\\t\\tsuffix = basename[ basename.rfind( '.' ) + 1 : ]\\n\\t\\t\\t\\tif suffix in ( 'xml', 'snapshot' ):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\tchoices.append( basename )\\n\\t\\tchoices.sort()\\n\\t\\tself.image_syntax.update_choices( choices )\\n\\n\\t\\t# recreate pool button\\n\\t\\tbtn = self._create_pool_select_button( object.options )\\n\\t\\tself[DriveWizard.PAGE_OLD].options[0] = btn\\n\\t\\tself[DriveWizard.PAGE_NEW].options[0] = btn\\n\\t\\t# recreate driver-type button\\n\\t\\titems = [self[DriveWizard.PAGE_NEW].options[2].id(), self[DriveWizard.PAGE_NEW].options[3].id()]\\n\\t\\tbtn = self._create_type_select_button(object.options, items)\\n\\t\\tself[DriveWizard.PAGE_NEW].options[1] = btn\\n\\n\\t\\tif drive_type == 'disk':\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].hint = None\\n\\t\\telif drive_type in ( 'cdrom', 'floppy' ):\\n\\t\\t\\tif self.image_syntax._choices:\\n\\t\\t\\t\\tmsg = _( \\\"If the required image is not found it might be added by copying the file into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\\\" )\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmsg = _( \\\"The list of available images is empty! To add an image the file needs to be copied into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\\\" )\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].hint = msg\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].description = ''\\n\\t\\telse:\\n\\t\\t\\traise ValueError('Invalid drive-type \\\"%s\\\"' % drive_type)\\n\\n\\t\\treturn self.type_selected(object)\",\n \"def selection(self):\\n if not self._selection:\\n return None\\n \\n year, month = self._date.year, self._date.month\\n return self.datetime(year, month, int(self._selection[0]))\",\n \"def __init__(self, r1=4.5*0.0254, r2=4.5*0.0254,\\n d1=25.0*0.0254, d2=25.0*0.0254,\\n Ixx=185000.0*0.45359237*0.0254**2,\\n Iyy=185000.0*0.45359237*0.0254**2,\\n Izz=3500.0*0.45359237*0.0254**2,):\\n self.r1 = r1 # m\\n self.r2 = r2 # m\\n self.d1 = d1 # m\\n self.d2 = d2 # m\\n self.Ixx = Ixx # kg-m^2\\n self.Iyy = Iyy # kg-m^2\\n self.Izz = Izz # kg-m^2\",\n \"def _generate_solution(self):\\n \\n operation_list = []\\n available = {job.get_job_id(): [operation for operation in job.get_operations() if operation.get_sequence() == 0] for job in self.jssp_instance_data.jobs} # dictionary of first unprocessed operations of each job\\n \\n while 0 < len(available):\\n rand_job_id = random.choice(list(available.keys()))\\n rand_operation = random.choice(available[rand_job_id])\\n rand_machine = np.random.choice(rand_operation.get_required_machines())\\n\\n available[rand_job_id].remove(rand_operation)\\n \\n if len(available[rand_job_id]) == 0:\\n # if selected operation is last operation of the job \\n if rand_operation.get_sequence() == self.jssp_instance_data.get_job(rand_job_id).get_max_sequence():\\n del available[rand_job_id]\\n else:\\n available[rand_job_id] = [t for t in self.jssp_instance_data.get_job(rand_job_id).get_operations() if\\n t.get_sequence() == rand_operation.get_sequence() + 1]\\n\\n\\n operation_list.append([rand_job_id, rand_operation.get_operation_id(), rand_operation.get_sequence(), rand_machine]) # chromosome representation \\n return Solution(self.jssp_instance_data, np.array(operation_list, dtype=np.intc))\",\n \"def __init__(self, dict = {}):\\r\\n if dict == {}:\\r\\n self.zero_val()\\r\\n else:\\r\\n self.piDD = dict\\r\\n self.top_node = utilities.max_length_in_list(self.return_keys())\\r\\n if self.piDD[self.top_node] == None:\\r\\n self.dim = 0\\r\\n else:\\r\\n self.dim = self.piDD[self.top_node][0][0]\",\n \"def __init__(self):\\n\\n self.P = list()\\n self.label = 0\",\n \"def __init__(self, radius=0.5, extra={}):\\n self.radius = radius\\n self.sensors = [] # array of Attached\\n self.id_sensors = None\\n self.id_dynamics = None # XXX\\n self.dynamics = None\\n self.extra = extra\\n\\n self.primitives = set()\\n\\n # Needs to be initialized before calling certain functions\\n self._state = None\",\n \"def _select(self):\\n sel = []\\n\\n # choose randomly while favouring fit individuals\\n lp = len(self.population) // 2\\n for _ in range(lp):\\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n while idx1 == idx2:\\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n\\n p1, p2 = self.population[idx1], self.population[idx2]\\n sel.append((p1, p2))\\n\\n return sel\",\n \"def eta23pi ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays\\n ## \\n pre_eta = self.make_selection (\\n ## the unique tag \\n 'PreEta3Pi' ,\\n ## algorithm type to be used\\n DaVinci__N3BodyDecays ,\\n ## input selections \\n [ self.pions () , self.pi0 () ] ,\\n ## algorithm properties \\n DecayDescriptor = \\\" eta -> pi+ pi- pi0\\\" ,\\n ## \\n Combination12Cut = \\\"\\\"\\\" ( AM < 700 * MeV ) &\\n ( ACHI2DOCA(1,2) < 12 ) \\n \\\"\\\"\\\" , \\n ##\\n CombinationCut = \\\"\\\"\\\"\\n ( APT > %s ) & ( ADAMASS ( 'eta' ) < 100 * MeV )\\n \\\"\\\"\\\" % ( 0.9 * self['ETA_PT'] ) ,\\n ##\\n MotherCut = \\\"\\\"\\\"\\n ( PT > %s ) &\\n ( chi2vx < 9 ) \\n \\\"\\\"\\\" % self['ETA_PT']\\n )\\n ##\\n from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger2g\\n ## \\n return self.make_selection (\\n 'Eta23pi' ,\\n Pi0Veto__Tagger2g ,\\n [ pre_eta ] ,\\n MassWindow = 25 * MeV ,\\n MassChi2 = -1 ,\\n ExtraInfoIndex = 25016 ## unique ! \\n )\",\n \"def __init__(self):\\n raise NotImplementedError('cannot create independent arc')\",\n \"def __init__(self, d):\\n\\t\\tself._coords = [0] * d\",\n \"def test_non_it(self):\\n self.idx = [9, 11, 6, 10, 12, 2, 8, 1, 5, 0, 7, 4, 3]\\n selector = PCovCUR(n_to_select=12, iterative=False)\\n selector.fit(self.X, self.y)\\n\\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))\",\n \"def __init__(self):\\n\\n # Assign a nullptr for the device-side pointers. These will be set if the GPU is utilized.\\n self.ng = int(0)\\n self.goals = ct.POINTER(ct.c_uint)()\\n self.currentHorizon = int(0)\\n self.V = ct.POINTER(ct.c_float)()\\n self.VPrime = ct.POINTER(ct.c_float)()\\n self.pi = ct.POINTER(ct.c_uint)()\\n self.ne = int(0)\\n self.expanded = ct.POINTER(ct.c_int)()\\n self.d_goals = ct.POINTER(ct.c_uint)()\\n self.d_S = ct.POINTER(ct.c_int)()\\n self.d_T = ct.POINTER(ct.c_float)()\\n self.d_R = ct.POINTER(ct.c_float)()\\n self.d_V = ct.POINTER(ct.c_float)()\\n self.d_VPrime = ct.POINTER(ct.c_float)()\\n self.d_pi = ct.POINTER(ct.c_uint)()\\n self.d_expanded = ct.POINTER(ct.c_int)()\\n\\n # Additional informative variables.\\n self.Rmin = None\\n self.Rmax = None\",\n \"def selected_choice(self):\\r\\n choice = zeros(self.num_agents)\\r\\n random_numbers = self.generate_random_numbers()\\r\\n\\r\\n self.prob_cumsum = self.cumprob().filled(-1)\\r\\n\\r\\n for i in range(self.num_choices):\\r\\n # Indicator for the zero cells in the choice array\\r\\n #indicator_zero_cells = ones(self.num_agents)\\r\\n indicator = array([True]*self.num_agents)\\r\\n\\r\\n zero_indices = choice == 0\\r\\n #indicator_zero_cells[~zero_indices] = ma.masked\\r\\n indicator[~zero_indices] = False\\r\\n\\r\\n # Indicator for the cells where the random number\\r\\n # is less than the probability\\r\\n #indicator_less_cells = ones(self.num_agents)\\r\\n #indicator_less_cells = array([True]*self.num_agents)\\r\\n less_indices = random_numbers < self.prob_cumsum[:,i]\\r\\n #indicator_less_cells[~less_indices] = ma.masked\\r\\n #indicator_less_cells\\r\\n indicator[~less_indices] = False\\r\\n\\r\\n\\r\\n #indicator_less_zero_cells = indicator_zero_cells + indicator_less_cells\\r\\n\\r\\n #indicator_less_zero_cells = indicator_less_zero_cells == 2\\r\\n\\r\\n choice[indicator] = i + 1\\r\\n\\r\\n choice.shape = (self.num_agents, 1)\\r\\n\\r\\n #alt_text = []\\r\\n #for i in choice:\\r\\n # alt_text.append(self.choices[int(i[0])-1])\\r\\n #alt_text = array(alt_text)\\r\\n #alt_text.shape = (self.num_agents, 1)\\r\\n\\r\\n #return alt_text\\r\\n #print choice\\r\\n return DataArray(choice, ['selected choice'])\",\n \"def __init__(self, analogue_selection='indep', clock_selection='in', cal_mode='no_cal', clk_speed=800):\\n self.value = 0\\n self.value |= (0b1 << 2) # disable chip version output bit\\n self.value |= (0b1 << 3) # set demux to 1:2\\n clk_bits = 0b00 if (clk_speed<125) else 0b01 if (clk_speed<250) else 0b10 if (clk_speed<500) else 0b11\\n self.value |= (clk_bits << 12) # control wait bit calibration value is dependent on clk speed\\n self.value |= (1 << 14) # set FDataReady to Fs/2. I don't know what this means\\n self.set_analogue_selection(analogue_selection)\\n self.set_clock_selection(clock_selection)\\n self.set_cal_mode(cal_mode)\",\n \"def pi(self):\\n return self(self._real_field().pi())\",\n \"def __init__(self):\\n super().__init__()\\n self.lambdaVar = 1.0\\n self.low = 0.0\\n self.type = 'Exponential'\\n self.distType = 'Continuous'\\n self.hasInfiniteBound = True\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def __init__(self, params):\\r\\n _params = {'Similarity': 0.97,\\r\\n 'Application': 'cdhit',\\r\\n 'Algorithm': 'cdhit: \\\"longest-sequence-first list removal algorithm\\\"'}\\r\\n _params.update(params)\\r\\n OtuPicker.__init__(self, _params)\",\n \"def __init__(self, goal=0, kP=1, kI=1, kD=1, init_pt=0):\\n self._pid_lock = threading.Lock()\\n\\n self.set_goal(goal)\\n self.reset(init_pt)\\n self.set_gains({\\n PIDController.KP_KEY: kP,\\n PIDController.KI_KEY: kI,\\n PIDController.KD_KEY: kD\\n })\",\n \"def select(self):\\n\\n return self.p[0], self.p[1]\",\n \"def __init__(\\n self, voltage={0:(0, 0)}, rate=500, repetitions=1,\\n board_name='cDAQ1Mod1', voltage_limits=None, num_channels=7):\\n self.board_name = board_name #Check Measurement and Automation Explorer\\n self._taskHandle = ctypes.c_void_p(0)\\n self.num_channels = num_channels\\n DAQmxErrChk(api.DAQmxCreateTask(\\\"\\\", ctypes.byref(self._taskHandle)))\\n DAQmxErrChk(api.DAQmxCreateAOVoltageChan(\\n self._taskHandle,\\n self.board_name + \\\"/ao0:%i\\\"%(num_channels - 1),\\n \\\"\\\",\\n ctypes.c_double(-10.0), #Minimum voltage\\n ctypes.c_double(10.0), #Maximum voltage\\n 10348, #DAQmx_Val_Volts; don't question it!\\n ctypes.c_void_p(0), #NULL\\n ))\\n self.num_points_written = ctypes.c_long(0)\\n self._unwritten_voltages = False\\n self._unplayed_voltages = False\\n self.set_voltage_and_timing(voltage, rate, repetitions, voltage_limits)\\n return None\",\n \"def get_selection(self, selection_name, format=None):\",\n \"def null(cls, d=2):\\n return cls(*[0 for i in range(d)])\",\n \"def circle(self):\\n return circle(self.N, self.o, self.r)\",\n \"def p_selection(p_init, it, n_iters):\\n it = int(it / n_iters * 10000)\\n\\n if 10 < it <= 50:\\n p = p_init / 2\\n elif 50 < it <= 200:\\n p = p_init / 4\\n elif 200 < it <= 500:\\n p = p_init / 8\\n elif 500 < it <= 1000:\\n p = p_init / 16\\n elif 1000 < it <= 2000:\\n p = p_init / 32\\n elif 2000 < it <= 4000:\\n p = p_init / 64\\n elif 4000 < it <= 6000:\\n p = p_init / 128\\n elif 6000 < it <= 8000:\\n p = p_init / 256\\n elif 8000 < it <= 10000:\\n p = p_init / 512\\n else:\\n p = p_init\\n\\n return p\",\n \"def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\\n self.GP = GPIOProcessor()\\n self.pin1 = self.GP.getPin(pin1)\\n self.pin2 = self.GP.getPin(pin2)\\n self.pin3 = self.GP.getPin(pin3)\\n self.pin4 = self.GP.getPin(pin4)\\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\\n\\n for k in range(4):\\n self.pinl[k].out()\\n\\n self.speed = 100.0\",\n \"def select_arm(self):\\n\\n # Exploitation\\n if random.uniform(0, 1) > self.epsilon:\\n return np.argmax(self.values)\\n\\n # Exploration\\n else:\\n return random.randrange(len(self.values))\",\n \"def pick(self):\\n\\n pickerdict = {}\\n current_value = 0\\n\\n if len(self.choices) == 0:\\n return None\\n\\n if len(self.choices) == 1:\\n return self.choices[0][0]\\n\\n for option in self.choices:\\n pickerdict[current_value] = option[0]\\n current_value += option[1]\\n\\n picker = random.randint(0, current_value)\\n last_value = 0\\n result = None\\n sorted_keys = sorted(pickerdict.keys())\\n\\n found = False\\n for key in sorted_keys:\\n if key >= picker:\\n result = pickerdict[last_value]\\n found = True\\n continue\\n last_value = key\\n\\n if not found:\\n result = pickerdict[sorted_keys[-1]]\\n\\n return result\",\n \"def select(self):\\n pass\",\n \"def select(self):\\n pass\",\n \"def __init__(self, choice):\\r\\n self.choice = choice\",\n \"def make_car():\\n car = Car() \\n car.drop_val = random.randint(0,1)\\n\\n if car.drop_val == 0:\\n car.drop_x = random.randint(77, 400) * 2\\n\\n elif car.drop_val == 1:\\n car.drop_y = random.randint(62, 300) *2\\n\\n return car\",\n \"def __init__(self, D, K):\\n\\t\\tself.D = D \\n\\t\\tself.K = K \\n\\t\\tself.V = np.zeros((D+1,K))\\n\\t\\treturn\",\n \"def dropdown(self):\\n # defaults = DDConfig(0.6, 0.6, 0, 0)\\n return DropDown(self.name, self.command, **self.config)\",\n \"def touching_choice(self,p):\\n\\n part = ['head', 'foot1', 'foot2', 'foot3', 'foot4', 'back', 'stomach', 'tail']\\n if len(self.select[p]) == 0:\\n return random.sample(part,2)\\n elif len(self.select[p]) == 1:\\n part.remove(self.select[p][0])\\n c = random.sample(part,1)\\n return [self.select[p][0], c[0]]\\n else:\\n return random.sample(self.select[p],2)\",\n \"def __init__(self, inplace=False):\\n super(SELU, self).__init__()\\n self.inplace = inplace\",\n \"def __init__(self, motor, OD_range=None, motor_range=None,\\n motor_min=None, OD_min=None, motor_max=None, OD_max=None):\\n self.motor = motor\\n if OD_range is not None:\\n self.OD_range = OD_range\\n if motor_range is not None:\\n self.motor_range = motor_range\\n\\n if motor_min is not None:\\n self.motor_min = motor_min\\n else:\\n self.motor_min = motor_range[0]\\n\\n if motor_max is not None:\\n self.motor_max = motor_max\\n else:\\n self.motor_max = motor_range[1]\\n\\n if OD_min is not None:\\n self.OD_min = OD_min\\n else:\\n self.OD_min = OD_range[0]\\n\\n if OD_max is not None:\\n self.OD_max = OD_max\\n else:\\n self.OD_max = OD_range[1]\",\n \"def select(self):\\r\\n pass\",\n \"def __init__(self, r: float, i: float = 0):\\n self.r = r\\n self.i = i\",\n \"def __init__(self, tpose, mpose, tselect=[], mselect=[]):\\n self.target = tpose\\n self.mobile = mpose\\n self.target_residues = res_selector_to_size_list(tselect)\\n self.mobile_residues = res_selector_to_size_list(mselect)\\n self.set_target_sequence()\\n self.set_mobile_sequence()\\n self.atoms = ['N','C','CA']\\n self.bb_rmsd = None\",\n \"def create_soft_cluster():\\n # node, index_component, inf_val = general.get_soft_selection()\\n soft_element_data = general.get_soft_selection()\\n selection = [vtx_component for vtx_component, inf_val in soft_element_data]\\n\\n pm.select(selection, r=True)\\n cluster = pm.cluster(relative=True)\\n\\n for vtx_component, inf_val in soft_element_data:\\n pm.percent(cluster[0], vtx_component, v=inf_val)\\n pm.select(cluster[1], r=True)\\n\\n return cluster\",\n \"def __init__(self):\\n {}\\n #generate a monoid Q\\n self.monoid_Q = self.generateQ()[0]\\n self.relationOfElements_Q = self.generateQ()[1]\\n self.p_Position = self.generateQ()[2]\\n self.qOfPosition = self.generateQ()[3]\\n #print(self.qOfPosition)\",\n \"def get_slider():\\n return dcc.RangeSlider(\\n id='hours',\\n value=[0, 23],\\n min=0,\\n max=23,\\n marks={i: str(i) for i in range(0, 24, 3)}\\n )\",\n \"def choose_pos(self):\\n s = self\\n\\n availablepos = []\\n for dblock in s.pjs.dblocks:\\n is_available = True\\n\\n for powerup in s.pjs.powerups:\\n if powerup.rects[0].overlap(dblock.rects[0]):\\n is_available = False\\n break\\n\\n if is_available:\\n availablepos.append(dblock.rpos)\\n\\n pos = random.randint(0, len(availablepos) - 1)\\n s.rpos = availablepos[pos]\",\n \"def zero_val(self):\\r\\n self.piDD = {\\\"[0]\\\": None}\\r\\n self.top_node = \\\"[0]\\\"\\r\\n self.dim = 0\",\n \"def __init__(self):\\n super().__init__()\\n self.low = 0.0\\n self.high = 1.0\\n self.alpha = 0.0\\n self.beta = 0.0\\n self.type = 'Beta'\\n self.distType = 'Continuous'\\n self.hasInfiniteBound = True\\n self.compatibleQuadrature.append('Jacobi')\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'Jacobi'\\n self.preferredPolynomials = 'Jacobi'\",\n \"def selectPointsUnderCursor(self):\\n spw = self.spw\\n sw = spw.windows['Sort']\\n #if clear:\\n # sw.uslist.clearSelection()\\n # sw.nlist.clearSelection()\\n x, y = self.cursorPosGL()\\n sids = self.pick(x, y, pb=10, multiple=True)\\n if sids is None:\\n return\\n #t0 = time.time()\\n spw.SelectSpikes(sids, on=self.selecting)\\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\\n if self.selecting == True:\\n sat = 0.2 # desaturate\\n else: # self.selecting == False\\n sat = 1 # resaturate\\n self.color(sids, sat=sat)\\n self.updateGL()\",\n \"def selection(self) -> Chromosome:\\n # each chromosome has a fitness, and the lower the fitness, the higher the probability of election\\n choices_list = list(range(len(self._population)))\\n weights = [1 / chromosome.get_fitness() for chromosome in self._population]\\n\\n index = choices(choices_list, weights=weights)[0]\\n\\n return self._population[index]\",\n \"def create_pressure_vessel_geometry():\\r\\n\\r\\n # configure sigmoid function\\r\\n bounds_upper = [3, 6]\\r\\n h = 5\\r\\n w = 6\\r\\n\\r\\n sigmoid_function = lambda x: (1 / (1 + np.exp(-1 * h * x + w))) + 1\\r\\n\\r\\n sigmoid_function_reverse = lambda x: 1 / (1 + np.exp(h * x - w - 18)) + 1\\r\\n\\r\\n funcs_upper = [sigmoid_function, sigmoid_function_reverse]\\r\\n\\r\\n bounds_lower = None\\r\\n funcs_lower = 0\\r\\n\\r\\n x_max = 6\\r\\n x_min = 0\\r\\n resolution = 10000\\r\\n\\r\\n pressure_vessel = Geometry(x_max, x_min, resolution,\\r\\n bounds_upper, funcs_upper,\\r\\n bounds_lower, funcs_lower)\\r\\n\\r\\n return pressure_vessel\",\n \"def random(cls, d=2, borns=[-1, 1], **kwargs):\\n components = [random.uniform(*borns) for i in range(d)]\\n return cls(*components, **kwargs)\",\n \"def random(cls, d=2, borns=[-1, 1], **kwargs):\\n components = [random.uniform(*borns) for i in range(d)]\\n return cls(*components, **kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60390633","0.5895539","0.55829453","0.5348063","0.5305103","0.5261155","0.5167734","0.51543236","0.5077886","0.5058524","0.50535107","0.50340015","0.5013713","0.49337313","0.49296355","0.48771095","0.48653218","0.48559302","0.48356175","0.48229763","0.47938704","0.47937343","0.47884813","0.4786957","0.47820017","0.47796422","0.4728191","0.47270483","0.4726566","0.47224525","0.47163728","0.4692927","0.4683308","0.4682291","0.4626385","0.4626385","0.4626385","0.4626385","0.4626385","0.4626385","0.4626385","0.4626385","0.4626385","0.46214193","0.46164653","0.46056542","0.46046007","0.46033987","0.4589671","0.4589013","0.45679867","0.4566554","0.4557653","0.45532042","0.45365626","0.4530548","0.45283732","0.45273715","0.45257515","0.4514184","0.45141345","0.45109862","0.44972917","0.44914532","0.44913852","0.44850183","0.4477581","0.44768035","0.44728625","0.44718337","0.44647622","0.44641063","0.44597855","0.44592988","0.4457611","0.44562554","0.44530872","0.44520926","0.44520926","0.44454646","0.44417307","0.44354388","0.44337845","0.4429657","0.44287014","0.44256827","0.44169018","0.44125795","0.44094974","0.440373","0.43920735","0.4389144","0.4388632","0.43877658","0.43853682","0.43819612","0.43802664","0.4378483","0.4376915","0.4376915"],"string":"[\n \"0.60390633\",\n \"0.5895539\",\n \"0.55829453\",\n \"0.5348063\",\n \"0.5305103\",\n \"0.5261155\",\n \"0.5167734\",\n \"0.51543236\",\n \"0.5077886\",\n \"0.5058524\",\n \"0.50535107\",\n \"0.50340015\",\n \"0.5013713\",\n \"0.49337313\",\n \"0.49296355\",\n \"0.48771095\",\n \"0.48653218\",\n \"0.48559302\",\n \"0.48356175\",\n \"0.48229763\",\n \"0.47938704\",\n \"0.47937343\",\n \"0.47884813\",\n \"0.4786957\",\n \"0.47820017\",\n \"0.47796422\",\n \"0.4728191\",\n \"0.47270483\",\n \"0.4726566\",\n \"0.47224525\",\n \"0.47163728\",\n \"0.4692927\",\n \"0.4683308\",\n \"0.4682291\",\n \"0.4626385\",\n \"0.4626385\",\n \"0.4626385\",\n \"0.4626385\",\n \"0.4626385\",\n \"0.4626385\",\n \"0.4626385\",\n \"0.4626385\",\n \"0.4626385\",\n \"0.46214193\",\n \"0.46164653\",\n \"0.46056542\",\n \"0.46046007\",\n \"0.46033987\",\n \"0.4589671\",\n \"0.4589013\",\n \"0.45679867\",\n \"0.4566554\",\n \"0.4557653\",\n \"0.45532042\",\n \"0.45365626\",\n \"0.4530548\",\n \"0.45283732\",\n \"0.45273715\",\n \"0.45257515\",\n \"0.4514184\",\n \"0.45141345\",\n \"0.45109862\",\n \"0.44972917\",\n \"0.44914532\",\n \"0.44913852\",\n \"0.44850183\",\n \"0.4477581\",\n \"0.44768035\",\n \"0.44728625\",\n \"0.44718337\",\n \"0.44647622\",\n \"0.44641063\",\n \"0.44597855\",\n \"0.44592988\",\n \"0.4457611\",\n \"0.44562554\",\n \"0.44530872\",\n \"0.44520926\",\n \"0.44520926\",\n \"0.44454646\",\n \"0.44417307\",\n \"0.44354388\",\n \"0.44337845\",\n \"0.4429657\",\n \"0.44287014\",\n \"0.44256827\",\n \"0.44169018\",\n \"0.44125795\",\n \"0.44094974\",\n \"0.440373\",\n \"0.43920735\",\n \"0.4389144\",\n \"0.4388632\",\n \"0.43877658\",\n \"0.43853682\",\n \"0.43819612\",\n \"0.43802664\",\n \"0.4378483\",\n \"0.4376915\",\n \"0.4376915\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6516377"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":7394,"cells":{"query":{"kind":"string","value":"Create and return a D > K pi pi+ Selection object."},"document":{"kind":"string","value":"def makeDPartial( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n _Kcuts1 = \"~ISMUON & (PT > %(DaugPtLoose)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2Loose)s)\" % locals()['config']\n _KcutsPIDK = \" & (PIDK > %(HighPIDK)s)\" % locals()['config']\n _Kcuts2 = \" & (ISLONG) & (P > %(DaugPLoose)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2Loose)s)\" % locals()['config']\n _Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\n _Picuts1 = \"~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)\" % locals()['config']\n _PicutsPIDK = \" & (PIDK < %(LowPIDK)s)\" % locals()['config']\n _Picuts2 = \" & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)\" % locals()['config']\n _Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\n _dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\n #_Kcuts1 = \"~ISMUON & (PT > 500* MeV) & (MIPCHI2DV(PRIMARY) > 4)\"\n #_KcutsPIDK = \" & (PIDK > 5)\"\n #_Kcuts2 = \" & (ISLONG) & (P > 5000* MeV) & (TRCHI2DOF < 5)\"\n #_Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2\n #_Picuts1 = \"~ISMUON & (PT > 500* MeV) & (MIPCHI2DV(PRIMARY) > 4)\"\n #_PicutsPIDK = \" & (PIDK < 0)\"\n #_Picuts2 = \" & (ISLONG) & (P > 5000* MeV) & (TRCHI2DOF < 5)\"\n #_Picuts = _Picuts1 + _PicutsPIDK + _Picuts2\n #_dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }\n\n _combCuts = \"(APT > %(D0PtLoose)s* MeV)\" \\\n \"& (AP > %(D0P)s* MeV)\" % locals()['config']\n\n _motherCuts = \"(VFASPF(VCHI2PDOF) < %(D0VtxChi2Ndof)s)\" \\\n \"& (BPVVDCHI2 > %(D0FDChi2)s)\" % locals()['config']\n\n\n _Dminus = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = _dauCuts\n , CombinationCut = _combCuts\n , MotherCut = _motherCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dminus,\n RequiredSelections = inputSel\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\n #\n ## check existing selection\n #\n sel = self._selection ( sel_tag )\n if sel : return sel \n\n #\n ## adjust a bit the arguments\n if not kwargs.has_key('Preambulo') :\n kwargs ['Preambulo' ] = self['Preambulo']\n\n if not kwargs.has_key( 'ParticleCombiners' ) :\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \n \n # \n ## use \"simple-selection\"\n #\n from PhysSelPython.Wrappers import SimpleSelection\n sel = SimpleSelection (\n sel_name ,\n algotype ,\n inputs , \n *args ,\n **kwargs )\n # \n return self._add_selection( sel_tag , sel )","def from_selection(cls):\n guid = compas_rhino.select_point()\n return cls.from_guid(guid)","def makeDstar2D0Pi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )","def create(cls, selection):\n\t\t\n\t\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })","def get_selection():\n\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\n sel_len = len(selected)\n result = SelectionContainer()\n\n for _x in range(0, sel_len):\n\n shape_type = selected[_x].ShapeType\n\n if shape_type == 'Vertex':\n result.vertices.append(selected[_x])\n\n elif shape_type == 'Edge':\n\n if 'Line' in str(selected[_x].Curve):\n result.lines.append(selected[_x])\n else:\n result.curves.append(selected[_x])","def curve_through_selection(*args):\n sel = cmds.ls(sl=True, fl=True)\n if not sel or len(sel)==1:\n cmds.warning(\"You need to select multiple things to create curve through!\")\n return()\n\n pList = []\n crvType = cmds.radioButtonGrp(widgets[\"crvSelRBG\"], q=True, sl=True)\n\n for obj in sel:\n if cmds.objectType(obj) in [\"transform\"]:\n pos = cmds.xform(obj, q=True, ws=True, rp=True)\n pList.append(pos)\n elif obj in cmds.filterExpand(sm=[28, 30, 31, 32, 34, 46]):\n pos = cmds.pointPosition(obj)\n pList.append(pos)\n\n #add points if only 2 (cv, ep) or 3 (cv) are given, and create the curve\n if crvType == 1:\n if len(pList) == 2:\n f = [float(sum(x)/2) for x in zip(*pList)]\n pList.insert(1, f)\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\n pList.insert(1, newPt1)\n pList.insert(3, newPt2)\n if len(pList) == 3:\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\n pList.insert(1, newPt1)\n pList.insert(3, newPt2)\n crv = cmds.curve(d=3, p=pList, name=\"newCurve\")\n\n if crvType == 2:\n if len(pList) == 2:\n f = [float(sum(x)/2) for x in zip(*pList)]\n pList.insert(1, f)\n crv = cmds.curve(d=3, ep=pList, name=\"newCurve\")\n\n return(crv)","def generate_kdtree(self):\n if self.method==2:\n coordinates = self.unassigned_data[0:3,:]\n else:\n coordinates = self.unassigned_data[0:2,:]\n tree = cKDTree(coordinates.T)\n\n return tree","def createSelector(self,type='select',speed=2.0):\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector.hide()\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def 选择项目(self, n): # real signature unknown; restored from __doc__\n return self.Select(n)","def selection(self):\n # create an empty priority queue for the new generation\n newGeneration = PriorityQueue()\n # pick top X of the population to survive\n for c in range(0, self.generation.qsize() / SELECTION_FRACTION):\n # get a chromosome\n chromosome = self.generation.get()\n # put the chromosomes in the new generation\n newGeneration.put(chromosome)\n # keep the new generation\n self.generation = newGeneration","def createSelector2(self,type='select',speed=2.0):\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector2.hide()\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def makeDefault(name,inputSel) :\n from Configurables import OfflineVertexFitter\n Detached4mu = CombineParticles(\"Combine\"+name)\n Detached4mu.DecayDescriptor = \"B_s0 -> mu+ mu- mu+ mu-\"\n # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:\n Detached4mu.addTool( OfflineVertexFitter )\n Detached4mu.ParticleCombiners.update( { \"\" : \"OfflineVertexFitter\"} )\n Detached4mu.OfflineVertexFitter.useResonanceVertex = False\n Detached4mu.ReFitPVs = True\n Detached4mu.DaughtersCuts = { \"mu+\" : \"(TRCHI2DOF < 2.5 ) \"\\\n \" & (MIPCHI2DV(PRIMARY)> 9.)\"}\n \n Detached4mu.CombinationCut = \"(ADAMASS('B_s0')<1000*MeV) \"\\\n \"& (AMAXDOCA('')<0.3*mm)\"\n Detached4mu.MotherCut = \"(VFASPF(VCHI2/VDOF)<9) \"\\\n \"& (BPVDIRA > 0) \"\\\n \"& (BPVVDCHI2>100)\"\\\n \" & (M>4366.3) & (M<6366.3)\"\\\n \"& (BPVIPCHI2()< 25) \"\n \n\n return Selection (name,\n Algorithm = Detached4mu,\n RequiredSelections = inputSel)","def from_selection(\n class_,\n selection,\n item_class=None,\n ):\n import abjad\n pitch_segment = abjad.PitchSegment.from_selection(selection)\n return class_(\n pitch_segment,\n item_class=item_class,\n )","def makePseudoPsi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n _daugCuts = \"(PT> %(D0PtLoose)s*MeV)\" % locals()['config']\n _combCuts = \"(APT> %(D0PtLoose)s*MeV)\" % locals()['config']\n\n _Psi = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"D0\": _daugCuts }\n , CombinationCut = _combCuts\n , MotherCut = \"(VFASPF(VCHI2PDOF) < 10000)\"\n )\n\n return Selection( name+'Sel',\n Algorithm = _Psi,\n RequiredSelections = inputSel\n )","def selectPointsUnderCursor(self):\n spw = self.spw\n sw = spw.windows['Sort']\n #if clear:\n # sw.uslist.clearSelection()\n # sw.nlist.clearSelection()\n x, y = self.cursorPosGL()\n sids = self.pick(x, y, pb=10, multiple=True)\n if sids is None:\n return\n #t0 = time.time()\n spw.SelectSpikes(sids, on=self.selecting)\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\n if self.selecting == True:\n sat = 0.2 # desaturate\n else: # self.selecting == False\n sat = 1 # resaturate\n self.color(sids, sat=sat)\n self.updateGL()","def get_gold_selection(self, pointer):\n raise NotImplementedError","def _select(self):\n sel = []\n\n # choose randomly while favouring fit individuals\n lp = len(self.population) // 2\n for _ in range(lp):\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n while idx1 == idx2:\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n\n p1, p2 = self.population[idx1], self.population[idx2]\n sel.append((p1, p2))\n\n return sel","def select(self):\n\t\tbest_num_components = self.n_constant\n\t\treturn self.base_model(best_num_components)","def eta23pi ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays\n ## \n pre_eta = self.make_selection (\n ## the unique tag \n 'PreEta3Pi' ,\n ## algorithm type to be used\n DaVinci__N3BodyDecays ,\n ## input selections \n [ self.pions () , self.pi0 () ] ,\n ## algorithm properties \n DecayDescriptor = \" eta -> pi+ pi- pi0\" ,\n ## \n Combination12Cut = \"\"\" ( AM < 700 * MeV ) &\n ( ACHI2DOCA(1,2) < 12 ) \n \"\"\" , \n ##\n CombinationCut = \"\"\"\n ( APT > %s ) & ( ADAMASS ( 'eta' ) < 100 * MeV )\n \"\"\" % ( 0.9 * self['ETA_PT'] ) ,\n ##\n MotherCut = \"\"\"\n ( PT > %s ) &\n ( chi2vx < 9 ) \n \"\"\" % self['ETA_PT']\n )\n ##\n from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger2g\n ## \n return self.make_selection (\n 'Eta23pi' ,\n Pi0Veto__Tagger2g ,\n [ pre_eta ] ,\n MassWindow = 25 * MeV ,\n MassChi2 = -1 ,\n ExtraInfoIndex = 25016 ## unique ! \n )","def get_selection(self, selection_name, format=None):","def __init__(self, P, I, D, dt):\n\n\t\tself._Kp = P\n\t\tself._Ki = I\n\t\tself._Kd = D\n\t\tself._dt = dt","def create_pauli_qiskit(pauli):\n\ttemp = [] # List in which save the weights and the Pauli strings\n\tfor key in pauli.keys(): # Iterate over all the Pauli strings\n\t\ttemp.append([pauli[key], Pauli(key)])\n\treturn WeightedPauliOperator(temp) # Transform the list into a qiskit operator","def selectPointsUnderCursor(self):\n #spw = self.spw\n #sw = spw.windows['Sort']\n #if clear:\n # sw.uslist.clearSelection()\n # sw.nlist.clearSelection()\n x, y = self.cursorPosGL()\n sids = self.pick(x, y, pb=10, multiple=True)\n if sids == None:\n return\n #t0 = time.time()\n #if not sw.panel.maxed_out:\n # spw.SelectSpikes(sids, on=self.selecting)\n #else:\n # # for speed, while the mouse is held down and the sort panel is maxed out,\n # # don't call SelectSpikes, only call it once when the mouse is released\n self.collected_sids.append(sids)\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\n if self.selecting == True:\n sat = 0.2 # desaturate\n else: # self.selecting == False\n sat = 1 # resaturate\n self.color(sids, sat=sat)\n self.updateGL()","def selection(self) -> Chromosome:\n # each chromosome has a fitness, and the lower the fitness, the higher the probability of election\n choices_list = list(range(len(self._population)))\n weights = [1 / chromosome.get_fitness() for chromosome in self._population]\n\n index = choices(choices_list, weights=weights)[0]\n\n return self._population[index]","def _selectRandomPrototypes(K, n, q):\n G = [] # Vector of prototypes\n elements = range(n) # Index of the elements of E\n for k in range(K):\n Gk = random.sample(elements, q)\n G.append(Gk)\n return G","def p_selection(p_init, it, n_iters):\n it = int(it / n_iters * 10000)\n\n if 10 < it <= 50:\n p = p_init / 2\n elif 50 < it <= 200:\n p = p_init / 4\n elif 200 < it <= 500:\n p = p_init / 8\n elif 500 < it <= 1000:\n p = p_init / 16\n elif 1000 < it <= 2000:\n p = p_init / 32\n elif 2000 < it <= 4000:\n p = p_init / 64\n elif 4000 < it <= 6000:\n p = p_init / 128\n elif 6000 < it <= 8000:\n p = p_init / 256\n elif 8000 < it <= 10000:\n p = p_init / 512\n else:\n p = p_init\n\n return p","def fitness_proportional_selection(self) -> List[Character]:\n print(' - selection')\n st = time.time()\n\n # open pool the the amount of cpu cores\n pool = mp.Pool(mp.cpu_count())\n\n # create a character at each position of the characters list\n new_list = pool.map(create_character, [i for i in self.characters])\n\n # close pool and release the cores\n pool.close()\n\n self.characters = new_list\n self.get_diversity()\n self.calc_sum_fitness()\n self.calc_average_fitness()\n self.get_best_fitness()\n self.get_worst_fitness()\n\n # create the wheel as dict with the selection chance and the character\n wheel: Dict[float, Character] = {}\n\n # the new generation\n new_generation: List[Character] = []\n fit_c_generation: float = 0\n new_wheel = {}\n \"\"\"get the chance of all characters to be selected\n \n \"\"\"\n for c in self.characters:\n p_chance = c.fitness / self.sum_fitness\n chance = p_chance * self.size\n s = str(chance)\n s = s.split('.')\n r = int(s[0])\n f_c = '0.' + s[1]\n f_c = float(f_c)\n fit_c_generation += f_c\n if r <= 0:\n wheel[f_c] = c\n while r > 0:\n new_character = copy.deepcopy(c)\n new_generation.append(new_character)\n r -= 1\n\n for k, v in wheel.items():\n new_key = (k / fit_c_generation) * self.size\n new_wheel[new_key] = v\n\n while len(new_generation) < self.size:\n for k in sorted(new_wheel, reverse=True):\n chance = random.uniform(0, fit_c_generation)\n if chance <= k:\n new_character = copy.deepcopy(new_wheel[k])\n new_generation.append(new_character)\n if len(new_generation) >= self.size:\n break\n continue\n e = time.time()\n print(\" - time: \", e - st)\n\n return new_generation","def select(self):\n\n return self.p[0], self.p[1]","def __init__(self, k, p, sample_p=1):\n # Maximum sample size\n self.k = k\n\n # A dictionary containing the sampled elements\n # The dictionary key is the key of the element\n # The value is a tuple (seed, count)\n self.elements = {}\n\n # The function of the frequencies that the sketch estimates\n # For now it's the p-th frequency moment, but in the future we may\n # support other functions (passed as a parameter)\n self.func_of_freq = lambda x: x**p\n\n # The power of values used for the sampling weights\n self.sample_p = sample_p","def selection(probs):\n # pick 2 parents out of this distribution\n t = [i for i in range(len(probs))]\n draw = choice(t, 2, p=probs, replace=False)\n return draw","def _add_selection ( self , nick , sel ) :\n if not self.__selections_.has_key ( self.name() ) :\n self.__selections_[ self.name() ] = {} \n \n if self.__selections_[ self.name()].has_key( nick ) :\n raise AttributeError , \"Selection '%s'already exists \" % nick\n \n self.__selections_[ self.name() ][ nick ] = sel\n \n return sel","def makeDstarPartial( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )","def project(record, selected, pkey_name) -> StateDictInterface:\n if selected:\n keys = set(selected.keys()) | {pkey_name}\n return record.projection(keys)\n else:\n return record","def select(self):\n pass","def select(self):\n pass","def build_selection_spec(client_factory, name):\r\n sel_spec = client_factory.create('ns0:SelectionSpec')\r\n sel_spec.name = name\r\n return sel_spec","def __init__(self, parent):\n # parent is the main frame of PyCorrFit\n self.parent = parent\n ## MYID\n # This ID is given by the parent for an instance of this class\n self.MyID = None\n ## Wrapping\n curvedict, labels = self.GetCurvedict()\n self.labels = labels\n self.Selector = UserSelectCurves(parent, curvedict,\n wrapper=self, labels=labels)\n # This is necessary for parent to deselect and select the tool\n # in the tools menu.\n self.Bind = self.Selector.Bind\n if self.parent.notebook.GetPageCount() == 0:\n self.Selector.sp.Disable()","def pions ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n ##\n if self['NOPIDHADRONS'] :\n from StandardParticles import StdAllNoPIDsPions as inpts\n pioncut = self['PionCut']\n else :\n from StandardParticles import StdAllLooseANNPions as inpts\n pioncut = \"(%s)&(%s)\" % ( self['PionCut'] , self['PionPIDCut'] ) \n ##\n return self.make_selection (\n 'Pion' ,\n FilterDesktop ,\n [ inpts ] ,\n Code = pioncut ,\n )","def from_selection(cls):\n guid = compas_rhino.select_mesh()\n return cls.from_guid(guid)","def make_odorant_selector(name):\n return dcc.Input(\n id=\"cid_%s\" % name,\n placeholder=\"Enter a PubChem ID number...\",\n type=\"number\",\n value=None,\n )","def _select_single(self, disc):\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)","def upsilon_pK ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays\n #\n return self.make_selection (\n 'Y&pK' ,\n DaVinci__N3BodyDecays ,\n [ self.upsilons() , self.protons() , self.kaons() ] ,\n ## algorithm properties \n DecayDescriptor = \"[Upsilon(4S) -> J/psi(1S) p+ K-]cc\" ,\n Combination12Cut = \"\"\"\n ( AM < 15 * GeV ) &\n ( ACHI2DOCA(1,2) < 16 )\n \"\"\" ,\n CombinationCut = \"\"\"\n ( AM < 15 * GeV ) &\n ( AM23 < 2000 * MeV ) & \n ( ( AM - AM1 - AM23 ) < 2.5 * GeV ) &\n ( ACHI2DOCA(1,3) < 16 ) &\n ( ACHI2DOCA(2,3) < 16 )\n \"\"\" ,\n MotherCut = \" chi2vxndf< 10 \" ,\n )","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\r\n pass","def select_item(items, weights, k):\n x = random.choices(items, weights=weights, k=k)\n return x","def makeSelection(self, selection=\"\"):\n\n\t\tif selection == \"\":\n\t\t\tprint \"usage: makeSelection(selection)\"\n\n\t\tsel_string = self.parseMacros(selection)\n\n\t\t# --- split by \";\" --- #\n\t\ttmp = []\n\t\tcols = []\n\t\tcols = sel_string.split(\";\")\n\t\tfor col in cols:\n\t\t\tinverse = False\n\t\t\tif col == \"\":\n\t\t\t\tcontinue\n\n\t\t\ttmp = string.split(col, \"=\")\n\t\t\tif \"!\" in tmp[0]:\n\t\t\t\tinverse = True\n\n\t\t\tif \"resi\" in tmp[0]:\n\t\t\t\tself.parseResI(tmp[1])\n\t\t\t\tself.invresi = inverse\n\t\t\telif \"resn\" in tmp[0]:\n\t\t\t\tself.parseResN(tmp[1])\n\t\t\t\tself.invresn = inverse\n\t\t\telif \"name\" in tmp[0]:\n\t\t\t\tself.parseAtom(tmp[1])\n\t\t\t\tself.invatom = inverse\n\t\t\telif \"element\" in tmp[0]:\n\t\t\t\tself.parseElement(tmp[1])\n\t\t\t\tself.invelement = inverse\t\n\t\t\telif \"chain\" in tmp[0]:\n\t\t\t\tself.parseChain(tmp[1])\n\t\t\t\tself.invchain = inverse\n\t\t\telif \"type\" in tmp[0]:\n\t\t\t\tself.parseType(tmp[1])\n\t\t\t\tself.invtype = inverse\n\t\t\telif \"cat\" in tmp[0]:\n\t\t\t\tself.parseCat(tmp[1])\n\t\t\t\tself.invcat = inverse\n\t\t\telif \"atomid\" in tmp[0]:\n\t\t\t\tself.parseAtomid(tmp[1])\n\t\t\t\tself.invatomid = inverse\n\t\t\telif \"BB\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O \")\n\t\t\t\tself.invatom = False\n\t\t\telif \"CEN\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O , CB \")\n\t\t\t\tself.invatom = False\n\t\t\telif \"SC\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O \")\n\t\t\t\tself.invatom = True\n\t\t\telif \"HET\" in tmp[0]:\n\t\t\t\tself.parseType(\"HETATM\")\n\t\t\t\tself.invtype = inverse\n\t\t\telse:\n\t\t\t\tprint \"unrecognized selector: \",tmp[0]\n\t\t\t\tsys.exit()","def choose(self, g, c, p):\n ng = copy.deepcopy(g)\n ng[c[0]][c[1]] = p\n return ng","def __init__(self, r=1, p=3):\n self.p = p\n self.r = r","def _gen_qiskit_gateset(q_circ):\n return {\n 'H': q_circ.h,\n 'X': q_circ.x,\n 'Y': q_circ.y,\n 'Z': q_circ.z,\n 'SWAP': q_circ.swap,\n 'I': q_circ.iden,\n 'S': q_circ.s,\n 'D-S': q_circ.sdg,\n 'T': q_circ.t,\n 'D-T': q_circ.tdg,\n 'RX': q_circ.rx,\n 'RY': q_circ.ry,\n 'RZ': q_circ.rz,\n 'C-H': q_circ.ch,\n 'CNOT': q_circ.cx,\n 'C-Y': q_circ.cy,\n 'CSIGN': q_circ.cz,\n 'C-RZ': q_circ.crz,\n 'CCNOT': q_circ.ccx,\n 'C-SWAP': q_circ.cswap,\n 'U': q_circ.u3,\n 'U3': q_circ.u3,\n 'U2': q_circ.u2,\n 'U1': q_circ.u1,\n 'U0': q_circ.iden,\n 'PH': q_circ.rz,\n 'RXX': q_circ.rxx,\n 'RZZ': q_circ.rzz,\n 'R': q_circ.r,\n 'MS': q_circ.ms\n }","def selectVertex(self, addToSelection: bool) -> None:\n ...","def new_piece(self):\n piece_type = pieces.PieceSelector.select_random_piece()\n return piece_type(game_config.NEXT_PIECE_POSX, game_config.NEXT_PIECE_POSY)","def __init__(\n self, name: str, values: List[Dict], index: Optional[int] = 0,\n label: Optional[str] = None, help: Optional[str] = None,\n default: Optional[bool] = None, required: Optional[bool] = False,\n group: Optional[str] = None\n ):\n super(Select, self).__init__(\n dtype=PARA_SELECT,\n name=name,\n index=index,\n label=label,\n help=help,\n default=default,\n required=required,\n group=group\n )\n self.values = values","def touching_choice(self,p):\n\n part = ['head', 'foot1', 'foot2', 'foot3', 'foot4', 'back', 'stomach', 'tail']\n if len(self.select[p]) == 0:\n return random.sample(part,2)\n elif len(self.select[p]) == 1:\n part.remove(self.select[p][0])\n c = random.sample(part,1)\n return [self.select[p][0], c[0]]\n else:\n return random.sample(self.select[p],2)","def select(self):\n return","def __init__(self, pvID, pvP, pvQ, pvDescriptor):\n\n # TODO: implement this","def upsilons ( self ) :\n ##\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n ##\n return self.make_selection (\n 'Upsilon' ,\n FilterDesktop , \n [ self.dimuon () ] , \n ## algorithm parameters \n Code = self['UpsilonCut'] ,\n ## \n ReFitPVs = True\n ##\n )","def selection(population: list, weights: list):\n\n new_population = list()\n\n for individual in population:\n new_population.append(individual[1])\n\n individuals = choices(new_population, weights=weights, k=2)\n\n return individuals[0], individuals[1]","def generatePDI(self,level='species',type='richness'):\n if type == 'richness':\n import biodiversity.richness as rich\n pdi = rich(self)\n try:\n return pdi[level]\n except:\n logger.error(\"[biospatial.gbif.taxonomy.distanceToTree] level selected non existent (used %s)\" %level)","def pool_selected( self, object ):\n\t\tud.debug( ud.ADMIN, ud.INFO, 'UVMM.DW.ps(node_uri=%s)' % self.node_uri)\n\t\tpool_name = object.options.get('pool-name')\n\t\tif not pool_name:\n\t\t\tpool_name = object.options['pool-name'] = 'default'\n\t\tdrive_type = object.options['drive-type']\n\t\ttry:\n\t\t\tif drive_type == 'cdrom':\n\t\t\t\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'cdrom')\n\t\t\telse:\n\t\t\t\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'disk' )\n\t\texcept uvmmd.UvmmError, e:\n\t\t\tvols = ()\n\t\tud.debug(ud.ADMIN, ud.INFO, 'UVMM.DW.ps: volumes=%s' % map(str, vols))\n\t\tchoices = []\n\t\tfor vol in vols:\n\t\t\tbasename = os.path.basename( vol.source )\n\t\t\tif '.' in basename:\n\t\t\t\tsuffix = basename[ basename.rfind( '.' ) + 1 : ]\n\t\t\t\tif suffix in ( 'xml', 'snapshot' ):\n\t\t\t\t\tcontinue\n\t\t\tchoices.append( basename )\n\t\tchoices.sort()\n\t\tself.image_syntax.update_choices( choices )\n\n\t\t# recreate pool button\n\t\tbtn = self._create_pool_select_button( object.options )\n\t\tself[DriveWizard.PAGE_OLD].options[0] = btn\n\t\tself[DriveWizard.PAGE_NEW].options[0] = btn\n\t\t# recreate driver-type button\n\t\titems = [self[DriveWizard.PAGE_NEW].options[2].id(), self[DriveWizard.PAGE_NEW].options[3].id()]\n\t\tbtn = self._create_type_select_button(object.options, items)\n\t\tself[DriveWizard.PAGE_NEW].options[1] = btn\n\n\t\tif drive_type == 'disk':\n\t\t\tself[DriveWizard.PAGE_OLD].hint = None\n\t\telif drive_type in ( 'cdrom', 'floppy' ):\n\t\t\tif self.image_syntax._choices:\n\t\t\t\tmsg = _( \"If the required image is not found it might be added by copying the file into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\" )\n\t\t\telse:\n\t\t\t\tmsg = _( \"The list of available images is empty! To add an image the file needs to be copied into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\" )\n\t\t\tself[DriveWizard.PAGE_OLD].hint = msg\n\t\t\tself[DriveWizard.PAGE_OLD].description = ''\n\t\telse:\n\t\t\traise ValueError('Invalid drive-type \"%s\"' % drive_type)\n\n\t\treturn self.type_selected(object)","def _getAsSelection(self):\n return self._asSelection","def New(*args, **kargs):\n obj = itkThresholdSegmentationLevelSetImageFilterID2ID2D.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def select_operator(operators, weights, rnd_state):\n return rnd_state.choice(np.arange(0, len(operators)),\n p=weights / np.sum(weights))","def partition_selection():\n if selection is None:\n warning(\"You need to pick something first.\")\n return\n if not selection.obj_type in ['actor','element']:\n warning(\"You need to pick actors or elements.\")\n return\n for A in GD.canvas.actors:\n if not A.atype() == 'TriSurface':\n warning(\"Currently I can only partition TriSurfaces.\" )\n return\n partitionCollection(selection)\n highlightPartitions(selection)","def __init__(self, selected_points, cut_depth, cut_breadth):\n\n\n self.cut_depth = cut_depth\n self.cut_breadth = cut_breadth\n\n self.points = selected_points\n\n self.vline = self.vlinecomp()\n self.hline = self.ortho_line_cut()\n\n self.mid_left = self.midpoint(0,1)\n self.mid_right = self.midpoint(2, 3)","def test_non_it(self):\n self.idx = [9, 11, 6, 10, 12, 2, 8, 1, 5, 0, 7, 4, 3]\n selector = PCovCUR(n_to_select=12, iterative=False)\n selector.fit(self.X, self.y)\n\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))","def getselected_nodes(self):\n self.selected_nodes = {}\n for path in self.options.selected_nodes:\n sel_data = path.rsplit(':', 2)\n path_id = sel_data[0]\n sub_path = int(sel_data[1])\n sel_node = int(sel_data[2])\n if path_id not in self.selected_nodes:\n self.selected_nodes[path_id] = {sub_path: [sel_node]}\n else:\n if sub_path not in self.selected_nodes[path_id]:\n self.selected_nodes[path_id][sub_path] = [sel_node]\n else:\n self.selected_nodes[path_id][sub_path].extend([sel_node])","def get_selection(self, name):\n print 'hi being selected in plotdata'\n return self.selections.get(name, None)","def __init__(self, cols, center, radius):\n ColorSelection.__init__(self, cols, center, radius)","def pdos_select(self, atoms=None, spin=None, l=None, m=None):\n valid_m_values = {'s': [],\n 'p': ['x', 'y', 'z'],\n 'd': ['xy', 'yz', 'z2-r2', 'xz', 'x2-y2'],\n 'f': ['y(3x2-y2)', 'xyz', 'yz2', 'z3', 'xz2', 'z(x2-y2)', 'x(x2-3y2)']}\n if not atoms:\n atom_idx = list(range(self.number_of_atoms))\n else:\n atom_idx = atoms\n to_return = self.pdos_raw[atom_idx, :, :, :]\n if not spin:\n spin_idx = list(range(self.ispin))\n elif spin == 'up':\n spin_idx = [0]\n elif spin == 'down':\n spin_idx = [1]\n elif spin == 'both':\n spin_idx = [0, 1]\n else:\n raise ValueError\n to_return = to_return[:, :, :, spin_idx]\n\n if not l:\n channel_idx = list(range(self.number_of_channels))\n elif l == 's':\n channel_idx = [0]\n elif l == 'p':\n if not m:\n channel_idx = [1, 2, 3]\n else:\n channel_idx = [1 + i for i, v in enumerate(valid_m_values['p']) if v in m]\n elif l == 'd':\n if not m:\n channel_idx = [4, 5, 6, 7, 8]\n else:\n channel_idx = [4 + i for i, v in enumerate(valid_m_values['d']) if v in m]\n elif l == 'f':\n if not m:\n channel_idx = [9, 10, 11, 12, 13, 14, 15]\n else:\n channel_idx = [9 + i for i, v in enumerate(valid_m_values['f']) if v in m]\n else:\n raise ValueError\n\n return to_return[:, :, channel_idx, :]","def __init__(self):\n super().__init__()\n self.p = 0.0\n self.type = 'Geometric'\n self.distType = 'Discrete'\n self.lowerBound = 0.0\n self.upperBound = 1.0\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def __init__(self):\n\n self.P = list()\n self.label = 0","def selectAdd(op):\n doc = op.GetDocument()\n doc.SetActiveObject(op, c4d.SELECTION_ADD)","def selection(self):\n\n # sort the generation according to fitness.\n self.sortByFitness()\n # get the fitness sum.\n fitnessSum = 0\n for outfit in self.currentGeneration:\n fitnessSum += self.applyFitness(outfit)\n # generate a random number\n stop = random.uniform(0, 1)\n accumulated = 0\n offset = 0\n for outfit in self.currentGenerationSorted:\n fitness = self.applyFitness(outfit) + offset\n probability = fitness / fitnessSum\n accumulated += probability\n\n if stop <= accumulated:\n return outfit","def make_selection(self, num):\n other_doors = None\n if num is 1:\n other_doors = [str(2), str(3)]\n elif num is 2:\n other_doors = [str(1), str(3)]\n elif num is 3:\n other_doors = [str(1), str(2)]\n\n reveal = str(random.choice(other_doors))\n other_doors.remove(reveal)\n third_door = random.choice(other_doors)\n other_doors.remove(third_door)\n\n main_door = getattr(self, 'door' + str(num) + '_counter')\n door_second = getattr(self, 'door' + reveal + '_counter')\n door_third = getattr(self, 'door' + third_door + '_counter')\n main_door_reveal = getattr(self, 'door'+str(num)+'_reveal')\n\n if (main_door is 0 and door_second is 0\n and door_third is 0):\n self.ids['door'+reveal].source = \\\n getattr(self, 'door'+reveal+'_reveal')\n self.ids['button'+reveal].disabled = True\n inc = getattr(self, 'door' + str(num) + '_counter')\n setattr(self, 'door' + str(num) + '_counter', inc + 1)\n elif main_door is 1 and door_second is 0 and door_third is 0:\n for i in range(1, 4, 1):\n self.ids['door' + str(i)].source = \\\n getattr(self, 'door' + str(i) + '_reveal')\n self.ids['button'+str(i)].disabled = True\n if main_door_reveal in ['door-money.png']:\n self.win_popup()\n else:\n self.lose_popup()\n elif main_door is 0 and (door_second is 1 or door_third is 1):\n for i in range(1, 4, 1):\n self.ids['door' + str(i)].source = \\\n getattr(self, 'door' + str(i) + '_reveal')\n self.ids['button'+str(i)].disabled = True\n if main_door_reveal in ['door-money.png']:\n self.win_popup()\n else:\n self.lose_popup()","def survivors_selection(self):\n q = 5\n new_population = []\n for i in range(self._population_size):\n batch = []\n for j in range(q):\n r = random.randint(0, (self._child2population_ratio + 1) * self._population_size - 1)\n if r < self._population_size:\n batch.append(self._population[r])\n else:\n batch.append(self._children[r - self._population_size])\n new_population.append(self.select_best(batch))\n\n self._population = new_population","def selection(self):\r\n if not self._selection:\r\n print(\"not working\")\r\n return None\r\n\r\n year, month = self._date.year, self._date.month\r\n if len(str(month))==1:\r\n month = \"0{}\".format(month)\r\n return (\"{}{}{}\".format(year, month, self._selection[0]), \r\n \"{} / {} / {}\".format(year, month, self._selection[0]))","def selection(self, name):\n try:\n return self._selections[name]\n except KeyError:\n raise Pype9NameError(\n \"No selection named '{}' (possible '{}')\"\n .format(name, \"', '\".join(self.selection_names)))","def New(*args, **kargs):\n obj = itkThresholdSegmentationLevelSetImageFilterID3ID3D.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def addSelectedToCanvas(self):\n\n selected = self.moduleList.currentItem()\n module = selected.data(QtCore.Qt.UserRole)[0]\n\n index = self.pickerUI.characterTabs.currentIndex()\n widget = self.pickerUI.characterTabs.widget(index)\n characterNode = widget.property(\"charNode\")\n\n # get inst\n modType = cmds.getAttr(module + \".moduleType\")\n modName = cmds.getAttr(module + \".moduleName\")\n mod = __import__(\"RigModules.\" + modType, {}, {}, [modType])\n reload(mod)\n\n # get the class name from that module file (returns RigModules.ART_Root.ART_Root for example)\n moduleClass = getattr(mod, mod.className)\n\n # find the instance of that module\n moduleInst = moduleClass(self, modName)\n self.modules.append(moduleInst)\n\n scene = self.getCurrentCanvasTab()\n\n # find out if charNode has a namespace\n if cmds.objExists(characterNode + \".namespace\"):\n namespace = cmds.getAttr(characterNode + \".namespace\") + \":\"\n else:\n namespace = \"\"\n\n # pass in the network node and the namespace\n picker = moduleInst.pickerUI(scene.sceneRect().center(), self.pickerUI, module, namespace)\n scene.addItem(picker[0])\n self.pickerUI.selectionScriptJobs.append(picker[2])\n\n # =======================================================================\n # #mirror the module's pickerBorderItem if needed\n # =======================================================================\n if picker[1] == True:\n picker[0].setTransformOriginPoint(picker[0].boundingRect().center())\n picker[0].setTransform(QtGui.QTransform(-1.0, 0.0, 0.0, 1.0, picker[0].boundingRect().width() * 2, 0.0))\n\n children = picker[0].childItems()\n if children is not None:\n self.mirrorChildren(children)\n\n row = self.moduleList.row(selected)\n self.moduleList.takeItem(row)","def choices(symbols, k):\n return [R.choice(symbols) for _ in range(k)]","def __call__(self) -> abjad.Selection:\n if (self._repetition_chance == 0.0\n or random.random() > self._repetition_chance):\n if not self._is_first_window or self._process_on_first_call:\n if self._mode == 'out':\n self._remove_element()\n else:\n self._add_element()\n elif not self._include_empty_measures and self._mode == 'in':\n self._add_element()\n self._mask_to_selection()\n return self.current_window","def pi(self):\n return self(self._real_field().pi())","def select(self, test):\n survivors = []\n for particle in self.particles:\n # Find the originating particle\n parent = particle\n while parent.origin is not None:\n parent = parent.origin.initial_state[0]\n if test(parent, particle) is True:\n survivors.append(particle)\n return ParticleCollection(survivors)","def __init__(self, k=1):\n self.k = k\n self.x = None\n self.y = None\n self.classes_ = None","def pick(self):\n\n pickerdict = {}\n current_value = 0\n\n if len(self.choices) == 0:\n return None\n\n if len(self.choices) == 1:\n return self.choices[0][0]\n\n for option in self.choices:\n pickerdict[current_value] = option[0]\n current_value += option[1]\n\n picker = random.randint(0, current_value)\n last_value = 0\n result = None\n sorted_keys = sorted(pickerdict.keys())\n\n found = False\n for key in sorted_keys:\n if key >= picker:\n result = pickerdict[last_value]\n found = True\n continue\n last_value = key\n\n if not found:\n result = pickerdict[sorted_keys[-1]]\n\n return result","def __init__(self, r1=4.5*0.0254, r2=4.5*0.0254,\n d1=25.0*0.0254, d2=25.0*0.0254,\n Ixx=185000.0*0.45359237*0.0254**2,\n Iyy=185000.0*0.45359237*0.0254**2,\n Izz=3500.0*0.45359237*0.0254**2,):\n self.r1 = r1 # m\n self.r2 = r2 # m\n self.d1 = d1 # m\n self.d2 = d2 # m\n self.Ixx = Ixx # kg-m^2\n self.Iyy = Iyy # kg-m^2\n self.Izz = Izz # kg-m^2","def _write_selec(parameters):\n # Load data\n from ._common import selections\n\n data = deepcopy(selections)\n if parameters[\"selections\"][\"integers\"]:\n data[\"integers\"].update(parameters[\"selections\"][\"integers\"])\n if len(parameters[\"selections\"][\"floats\"]):\n data[\"floats\"] = parameters[\"selections\"][\"floats\"]\n\n # Check floats and overwrite IE(1)\n if data[\"floats\"] is not None and len(data[\"floats\"]):\n if isinstance(data[\"floats\"][0], (list, tuple, numpy.ndarray)):\n for x in data[\"floats\"]:\n if len(x) > 8:\n raise ValueError()\n\n data[\"integers\"][1] = len(data[\"floats\"])\n ndim = 2\n\n else:\n if len(data[\"floats\"]) > 8:\n raise ValueError()\n\n data[\"integers\"][1] = 1\n ndim = 1\n else:\n ndim = None\n\n # Formats\n fmt = block_to_format[\"SELEC\"]\n fmt1 = str2format(fmt[1])\n fmt2 = str2format(fmt[2])\n\n # Record 1\n values = [data[\"integers\"][k] for k in sorted(data[\"integers\"].keys())]\n out = write_record(values, fmt1)\n\n # Record 2\n if ndim == 1:\n out += write_record(data[\"floats\"], fmt2)\n elif ndim == 2:\n for x in data[\"floats\"]:\n out += write_record(x, fmt2)\n\n return out","def ImagePointPicker(img, pts = 4, **kwargs):\n\timgpicker = __ImgPicker(img, pts, **kwargs)\n\treturn imgpicker.pickedPoints","def pairing_group_create(curve='MNT224'):\n return PairingGroup(curve)","def _selection(self, evaluations, selection, method=\"truncated\", best_rate=0.2):\n\n if selection:\n end_range_for_parents = max(1, int(self.population_size * best_rate))\n evaluations_sorted = torch.sort(evaluations)\n population_sorted = self.population[evaluations_sorted[1]]\n\n if self.best_individual is None:\n self.best_individual = population_sorted[0]\n self.best_eval = evaluations_sorted[0][0]\n elif self.best_eval > evaluations_sorted[0][0]:\n self.best_individual = population_sorted[0]\n self.best_eval = evaluations_sorted[0][0]\n best_population = torch.zeros([end_range_for_parents, len(self.population[0])], device=self.device)\n if method == \"truncated\":\n \"\"\"\n returns best individuals\n \"\"\"\n best_population = population_sorted[:end_range_for_parents]\n elif method == \"fitness_based\":\n \"\"\"\n probability of each individual to be selected is proportional to its fitness value\n \"\"\"\n tot = sum(evaluations)\n probabilities = evaluations / tot\n for i in range(end_range_for_parents):\n best_idx = torch.distributions.categorical.Categorical(\n probabilities.clone().detach()).sample()\n best_population[i] = self.population[best_idx]\n # avoid repetitions\n probabilities[best_idx] = 0\n elif method == \"rank_based\":\n \"\"\"\n probability of each individual to be selected is proportional to its rank value\n \"\"\"\n tot = ((1 + len(evaluations)) / 2) * len(evaluations)\n ranks = torch.linspace(1, len(evaluations), steps=len(evaluations), device=self.device)\n sorted_probabilities = 1 - ranks / tot\n for i in range(end_range_for_parents):\n best_idx = torch.distributions.categorical.Categorical(\n sorted_probabilities).sample()\n best_population[i] = population_sorted[best_idx]\n # avoid repetitions\n sorted_probabilities[best_idx] = 0\n if self.elitism:\n best_population[end_range_for_parents - 1] = self.best_individual\n else:\n best_population = self.population\n return best_population","def legalize_Select(optree):\n cond = optree.get_input(0)\n op0 = optree.get_input(1)\n op1 = optree.get_input(2)\n precision = optree.get_precision()\n if precision is None:\n Log.report(Log.Error, \"None precision for Select:\\n{}\", optree)\n if op0.get_precision().get_bit_size() != precision.get_bit_size():\n optree.set_input(\n 1,\n Conversion(\n op0,\n precision = precision\n )\n )\n if op1.get_precision().get_bit_size() != precision.get_bit_size():\n optree.set_input(\n 2,\n Conversion(\n op1,\n precision = optree.get_precision()\n )\n )\n return optree","def pkj1pk(self,r,z=0):\n return M.sqrt(M.pi/2.0)/r*self.besselInt.besselInt(lambda k: self.delta(k/r, z)/M.sqrt(k),1.5,self.besselN,self.besselh)","def get_computers_choice():\n choices = ['Rock', 'Paper', 'Scissors']\n choice_index = randint(0, 2)\n choice = choices[choice_index]\n return choice"],"string":"[\n \"def make_selection ( self ,\\n tag , \\n algotype ,\\n inputs , \\n *args ,\\n **kwargs ) :\\n sel_tag = '%s_Selection' % tag\\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\\n #\\n ## check existing selection\\n #\\n sel = self._selection ( sel_tag )\\n if sel : return sel \\n\\n #\\n ## adjust a bit the arguments\\n if not kwargs.has_key('Preambulo') :\\n kwargs ['Preambulo' ] = self['Preambulo']\\n\\n if not kwargs.has_key( 'ParticleCombiners' ) :\\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \\n \\n # \\n ## use \\\"simple-selection\\\"\\n #\\n from PhysSelPython.Wrappers import SimpleSelection\\n sel = SimpleSelection (\\n sel_name ,\\n algotype ,\\n inputs , \\n *args ,\\n **kwargs )\\n # \\n return self._add_selection( sel_tag , sel )\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_point()\\n return cls.from_guid(guid)\",\n \"def makeDstar2D0Pi( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n daugCuts = \\\"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\\\" % locals()['config']\\n combCuts = \\\"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\\\" % locals()['config']\\n dstarCuts = \\\"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\\\" \\\\\\n \\\"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\\\" % locals()['config']\\n\\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"pi+\\\" : daugCuts }\\n , CombinationCut = combCuts\\n , MotherCut = dstarCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dstar,\\n RequiredSelections = inputSel\\n )\",\n \"def create(cls, selection):\\n\\t\\t\\n\\t\\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })\",\n \"def get_selection():\\n\\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\\n sel_len = len(selected)\\n result = SelectionContainer()\\n\\n for _x in range(0, sel_len):\\n\\n shape_type = selected[_x].ShapeType\\n\\n if shape_type == 'Vertex':\\n result.vertices.append(selected[_x])\\n\\n elif shape_type == 'Edge':\\n\\n if 'Line' in str(selected[_x].Curve):\\n result.lines.append(selected[_x])\\n else:\\n result.curves.append(selected[_x])\",\n \"def curve_through_selection(*args):\\n sel = cmds.ls(sl=True, fl=True)\\n if not sel or len(sel)==1:\\n cmds.warning(\\\"You need to select multiple things to create curve through!\\\")\\n return()\\n\\n pList = []\\n crvType = cmds.radioButtonGrp(widgets[\\\"crvSelRBG\\\"], q=True, sl=True)\\n\\n for obj in sel:\\n if cmds.objectType(obj) in [\\\"transform\\\"]:\\n pos = cmds.xform(obj, q=True, ws=True, rp=True)\\n pList.append(pos)\\n elif obj in cmds.filterExpand(sm=[28, 30, 31, 32, 34, 46]):\\n pos = cmds.pointPosition(obj)\\n pList.append(pos)\\n\\n #add points if only 2 (cv, ep) or 3 (cv) are given, and create the curve\\n if crvType == 1:\\n if len(pList) == 2:\\n f = [float(sum(x)/2) for x in zip(*pList)]\\n pList.insert(1, f)\\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\\n pList.insert(1, newPt1)\\n pList.insert(3, newPt2)\\n if len(pList) == 3:\\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\\n pList.insert(1, newPt1)\\n pList.insert(3, newPt2)\\n crv = cmds.curve(d=3, p=pList, name=\\\"newCurve\\\")\\n\\n if crvType == 2:\\n if len(pList) == 2:\\n f = [float(sum(x)/2) for x in zip(*pList)]\\n pList.insert(1, f)\\n crv = cmds.curve(d=3, ep=pList, name=\\\"newCurve\\\")\\n\\n return(crv)\",\n \"def generate_kdtree(self):\\n if self.method==2:\\n coordinates = self.unassigned_data[0:3,:]\\n else:\\n coordinates = self.unassigned_data[0:2,:]\\n tree = cKDTree(coordinates.T)\\n\\n return tree\",\n \"def createSelector(self,type='select',speed=2.0):\\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector.hide()\\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def 选择项目(self, n): # real signature unknown; restored from __doc__\\n return self.Select(n)\",\n \"def selection(self):\\n # create an empty priority queue for the new generation\\n newGeneration = PriorityQueue()\\n # pick top X of the population to survive\\n for c in range(0, self.generation.qsize() / SELECTION_FRACTION):\\n # get a chromosome\\n chromosome = self.generation.get()\\n # put the chromosomes in the new generation\\n newGeneration.put(chromosome)\\n # keep the new generation\\n self.generation = newGeneration\",\n \"def createSelector2(self,type='select',speed=2.0):\\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector2.hide()\\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def makeDefault(name,inputSel) :\\n from Configurables import OfflineVertexFitter\\n Detached4mu = CombineParticles(\\\"Combine\\\"+name)\\n Detached4mu.DecayDescriptor = \\\"B_s0 -> mu+ mu- mu+ mu-\\\"\\n # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:\\n Detached4mu.addTool( OfflineVertexFitter )\\n Detached4mu.ParticleCombiners.update( { \\\"\\\" : \\\"OfflineVertexFitter\\\"} )\\n Detached4mu.OfflineVertexFitter.useResonanceVertex = False\\n Detached4mu.ReFitPVs = True\\n Detached4mu.DaughtersCuts = { \\\"mu+\\\" : \\\"(TRCHI2DOF < 2.5 ) \\\"\\\\\\n \\\" & (MIPCHI2DV(PRIMARY)> 9.)\\\"}\\n \\n Detached4mu.CombinationCut = \\\"(ADAMASS('B_s0')<1000*MeV) \\\"\\\\\\n \\\"& (AMAXDOCA('')<0.3*mm)\\\"\\n Detached4mu.MotherCut = \\\"(VFASPF(VCHI2/VDOF)<9) \\\"\\\\\\n \\\"& (BPVDIRA > 0) \\\"\\\\\\n \\\"& (BPVVDCHI2>100)\\\"\\\\\\n \\\" & (M>4366.3) & (M<6366.3)\\\"\\\\\\n \\\"& (BPVIPCHI2()< 25) \\\"\\n \\n\\n return Selection (name,\\n Algorithm = Detached4mu,\\n RequiredSelections = inputSel)\",\n \"def from_selection(\\n class_,\\n selection,\\n item_class=None,\\n ):\\n import abjad\\n pitch_segment = abjad.PitchSegment.from_selection(selection)\\n return class_(\\n pitch_segment,\\n item_class=item_class,\\n )\",\n \"def makePseudoPsi( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n _daugCuts = \\\"(PT> %(D0PtLoose)s*MeV)\\\" % locals()['config']\\n _combCuts = \\\"(APT> %(D0PtLoose)s*MeV)\\\" % locals()['config']\\n\\n _Psi = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"D0\\\": _daugCuts }\\n , CombinationCut = _combCuts\\n , MotherCut = \\\"(VFASPF(VCHI2PDOF) < 10000)\\\"\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Psi,\\n RequiredSelections = inputSel\\n )\",\n \"def selectPointsUnderCursor(self):\\n spw = self.spw\\n sw = spw.windows['Sort']\\n #if clear:\\n # sw.uslist.clearSelection()\\n # sw.nlist.clearSelection()\\n x, y = self.cursorPosGL()\\n sids = self.pick(x, y, pb=10, multiple=True)\\n if sids is None:\\n return\\n #t0 = time.time()\\n spw.SelectSpikes(sids, on=self.selecting)\\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\\n if self.selecting == True:\\n sat = 0.2 # desaturate\\n else: # self.selecting == False\\n sat = 1 # resaturate\\n self.color(sids, sat=sat)\\n self.updateGL()\",\n \"def get_gold_selection(self, pointer):\\n raise NotImplementedError\",\n \"def _select(self):\\n sel = []\\n\\n # choose randomly while favouring fit individuals\\n lp = len(self.population) // 2\\n for _ in range(lp):\\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n while idx1 == idx2:\\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n\\n p1, p2 = self.population[idx1], self.population[idx2]\\n sel.append((p1, p2))\\n\\n return sel\",\n \"def select(self):\\n\\t\\tbest_num_components = self.n_constant\\n\\t\\treturn self.base_model(best_num_components)\",\n \"def eta23pi ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays\\n ## \\n pre_eta = self.make_selection (\\n ## the unique tag \\n 'PreEta3Pi' ,\\n ## algorithm type to be used\\n DaVinci__N3BodyDecays ,\\n ## input selections \\n [ self.pions () , self.pi0 () ] ,\\n ## algorithm properties \\n DecayDescriptor = \\\" eta -> pi+ pi- pi0\\\" ,\\n ## \\n Combination12Cut = \\\"\\\"\\\" ( AM < 700 * MeV ) &\\n ( ACHI2DOCA(1,2) < 12 ) \\n \\\"\\\"\\\" , \\n ##\\n CombinationCut = \\\"\\\"\\\"\\n ( APT > %s ) & ( ADAMASS ( 'eta' ) < 100 * MeV )\\n \\\"\\\"\\\" % ( 0.9 * self['ETA_PT'] ) ,\\n ##\\n MotherCut = \\\"\\\"\\\"\\n ( PT > %s ) &\\n ( chi2vx < 9 ) \\n \\\"\\\"\\\" % self['ETA_PT']\\n )\\n ##\\n from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger2g\\n ## \\n return self.make_selection (\\n 'Eta23pi' ,\\n Pi0Veto__Tagger2g ,\\n [ pre_eta ] ,\\n MassWindow = 25 * MeV ,\\n MassChi2 = -1 ,\\n ExtraInfoIndex = 25016 ## unique ! \\n )\",\n \"def get_selection(self, selection_name, format=None):\",\n \"def __init__(self, P, I, D, dt):\\n\\n\\t\\tself._Kp = P\\n\\t\\tself._Ki = I\\n\\t\\tself._Kd = D\\n\\t\\tself._dt = dt\",\n \"def create_pauli_qiskit(pauli):\\n\\ttemp = [] # List in which save the weights and the Pauli strings\\n\\tfor key in pauli.keys(): # Iterate over all the Pauli strings\\n\\t\\ttemp.append([pauli[key], Pauli(key)])\\n\\treturn WeightedPauliOperator(temp) # Transform the list into a qiskit operator\",\n \"def selectPointsUnderCursor(self):\\n #spw = self.spw\\n #sw = spw.windows['Sort']\\n #if clear:\\n # sw.uslist.clearSelection()\\n # sw.nlist.clearSelection()\\n x, y = self.cursorPosGL()\\n sids = self.pick(x, y, pb=10, multiple=True)\\n if sids == None:\\n return\\n #t0 = time.time()\\n #if not sw.panel.maxed_out:\\n # spw.SelectSpikes(sids, on=self.selecting)\\n #else:\\n # # for speed, while the mouse is held down and the sort panel is maxed out,\\n # # don't call SelectSpikes, only call it once when the mouse is released\\n self.collected_sids.append(sids)\\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\\n if self.selecting == True:\\n sat = 0.2 # desaturate\\n else: # self.selecting == False\\n sat = 1 # resaturate\\n self.color(sids, sat=sat)\\n self.updateGL()\",\n \"def selection(self) -> Chromosome:\\n # each chromosome has a fitness, and the lower the fitness, the higher the probability of election\\n choices_list = list(range(len(self._population)))\\n weights = [1 / chromosome.get_fitness() for chromosome in self._population]\\n\\n index = choices(choices_list, weights=weights)[0]\\n\\n return self._population[index]\",\n \"def _selectRandomPrototypes(K, n, q):\\n G = [] # Vector of prototypes\\n elements = range(n) # Index of the elements of E\\n for k in range(K):\\n Gk = random.sample(elements, q)\\n G.append(Gk)\\n return G\",\n \"def p_selection(p_init, it, n_iters):\\n it = int(it / n_iters * 10000)\\n\\n if 10 < it <= 50:\\n p = p_init / 2\\n elif 50 < it <= 200:\\n p = p_init / 4\\n elif 200 < it <= 500:\\n p = p_init / 8\\n elif 500 < it <= 1000:\\n p = p_init / 16\\n elif 1000 < it <= 2000:\\n p = p_init / 32\\n elif 2000 < it <= 4000:\\n p = p_init / 64\\n elif 4000 < it <= 6000:\\n p = p_init / 128\\n elif 6000 < it <= 8000:\\n p = p_init / 256\\n elif 8000 < it <= 10000:\\n p = p_init / 512\\n else:\\n p = p_init\\n\\n return p\",\n \"def fitness_proportional_selection(self) -> List[Character]:\\n print(' - selection')\\n st = time.time()\\n\\n # open pool the the amount of cpu cores\\n pool = mp.Pool(mp.cpu_count())\\n\\n # create a character at each position of the characters list\\n new_list = pool.map(create_character, [i for i in self.characters])\\n\\n # close pool and release the cores\\n pool.close()\\n\\n self.characters = new_list\\n self.get_diversity()\\n self.calc_sum_fitness()\\n self.calc_average_fitness()\\n self.get_best_fitness()\\n self.get_worst_fitness()\\n\\n # create the wheel as dict with the selection chance and the character\\n wheel: Dict[float, Character] = {}\\n\\n # the new generation\\n new_generation: List[Character] = []\\n fit_c_generation: float = 0\\n new_wheel = {}\\n \\\"\\\"\\\"get the chance of all characters to be selected\\n \\n \\\"\\\"\\\"\\n for c in self.characters:\\n p_chance = c.fitness / self.sum_fitness\\n chance = p_chance * self.size\\n s = str(chance)\\n s = s.split('.')\\n r = int(s[0])\\n f_c = '0.' + s[1]\\n f_c = float(f_c)\\n fit_c_generation += f_c\\n if r <= 0:\\n wheel[f_c] = c\\n while r > 0:\\n new_character = copy.deepcopy(c)\\n new_generation.append(new_character)\\n r -= 1\\n\\n for k, v in wheel.items():\\n new_key = (k / fit_c_generation) * self.size\\n new_wheel[new_key] = v\\n\\n while len(new_generation) < self.size:\\n for k in sorted(new_wheel, reverse=True):\\n chance = random.uniform(0, fit_c_generation)\\n if chance <= k:\\n new_character = copy.deepcopy(new_wheel[k])\\n new_generation.append(new_character)\\n if len(new_generation) >= self.size:\\n break\\n continue\\n e = time.time()\\n print(\\\" - time: \\\", e - st)\\n\\n return new_generation\",\n \"def select(self):\\n\\n return self.p[0], self.p[1]\",\n \"def __init__(self, k, p, sample_p=1):\\n # Maximum sample size\\n self.k = k\\n\\n # A dictionary containing the sampled elements\\n # The dictionary key is the key of the element\\n # The value is a tuple (seed, count)\\n self.elements = {}\\n\\n # The function of the frequencies that the sketch estimates\\n # For now it's the p-th frequency moment, but in the future we may\\n # support other functions (passed as a parameter)\\n self.func_of_freq = lambda x: x**p\\n\\n # The power of values used for the sampling weights\\n self.sample_p = sample_p\",\n \"def selection(probs):\\n # pick 2 parents out of this distribution\\n t = [i for i in range(len(probs))]\\n draw = choice(t, 2, p=probs, replace=False)\\n return draw\",\n \"def _add_selection ( self , nick , sel ) :\\n if not self.__selections_.has_key ( self.name() ) :\\n self.__selections_[ self.name() ] = {} \\n \\n if self.__selections_[ self.name()].has_key( nick ) :\\n raise AttributeError , \\\"Selection '%s'already exists \\\" % nick\\n \\n self.__selections_[ self.name() ][ nick ] = sel\\n \\n return sel\",\n \"def makeDstarPartial( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n daugCuts = \\\"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\\\" % locals()['config']\\n combCuts = \\\"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\\\" % locals()['config']\\n dstarCuts = \\\"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\\\" \\\\\\n \\\"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\\\" % locals()['config']\\n\\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"pi+\\\" : daugCuts }\\n , CombinationCut = combCuts\\n , MotherCut = dstarCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dstar,\\n RequiredSelections = inputSel\\n )\",\n \"def project(record, selected, pkey_name) -> StateDictInterface:\\n if selected:\\n keys = set(selected.keys()) | {pkey_name}\\n return record.projection(keys)\\n else:\\n return record\",\n \"def select(self):\\n pass\",\n \"def select(self):\\n pass\",\n \"def build_selection_spec(client_factory, name):\\r\\n sel_spec = client_factory.create('ns0:SelectionSpec')\\r\\n sel_spec.name = name\\r\\n return sel_spec\",\n \"def __init__(self, parent):\\n # parent is the main frame of PyCorrFit\\n self.parent = parent\\n ## MYID\\n # This ID is given by the parent for an instance of this class\\n self.MyID = None\\n ## Wrapping\\n curvedict, labels = self.GetCurvedict()\\n self.labels = labels\\n self.Selector = UserSelectCurves(parent, curvedict,\\n wrapper=self, labels=labels)\\n # This is necessary for parent to deselect and select the tool\\n # in the tools menu.\\n self.Bind = self.Selector.Bind\\n if self.parent.notebook.GetPageCount() == 0:\\n self.Selector.sp.Disable()\",\n \"def pions ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n ##\\n if self['NOPIDHADRONS'] :\\n from StandardParticles import StdAllNoPIDsPions as inpts\\n pioncut = self['PionCut']\\n else :\\n from StandardParticles import StdAllLooseANNPions as inpts\\n pioncut = \\\"(%s)&(%s)\\\" % ( self['PionCut'] , self['PionPIDCut'] ) \\n ##\\n return self.make_selection (\\n 'Pion' ,\\n FilterDesktop ,\\n [ inpts ] ,\\n Code = pioncut ,\\n )\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_mesh()\\n return cls.from_guid(guid)\",\n \"def make_odorant_selector(name):\\n return dcc.Input(\\n id=\\\"cid_%s\\\" % name,\\n placeholder=\\\"Enter a PubChem ID number...\\\",\\n type=\\\"number\\\",\\n value=None,\\n )\",\n \"def _select_single(self, disc):\\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)\",\n \"def upsilon_pK ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays\\n #\\n return self.make_selection (\\n 'Y&pK' ,\\n DaVinci__N3BodyDecays ,\\n [ self.upsilons() , self.protons() , self.kaons() ] ,\\n ## algorithm properties \\n DecayDescriptor = \\\"[Upsilon(4S) -> J/psi(1S) p+ K-]cc\\\" ,\\n Combination12Cut = \\\"\\\"\\\"\\n ( AM < 15 * GeV ) &\\n ( ACHI2DOCA(1,2) < 16 )\\n \\\"\\\"\\\" ,\\n CombinationCut = \\\"\\\"\\\"\\n ( AM < 15 * GeV ) &\\n ( AM23 < 2000 * MeV ) & \\n ( ( AM - AM1 - AM23 ) < 2.5 * GeV ) &\\n ( ACHI2DOCA(1,3) < 16 ) &\\n ( ACHI2DOCA(2,3) < 16 )\\n \\\"\\\"\\\" ,\\n MotherCut = \\\" chi2vxndf< 10 \\\" ,\\n )\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\r\\n pass\",\n \"def select_item(items, weights, k):\\n x = random.choices(items, weights=weights, k=k)\\n return x\",\n \"def makeSelection(self, selection=\\\"\\\"):\\n\\n\\t\\tif selection == \\\"\\\":\\n\\t\\t\\tprint \\\"usage: makeSelection(selection)\\\"\\n\\n\\t\\tsel_string = self.parseMacros(selection)\\n\\n\\t\\t# --- split by \\\";\\\" --- #\\n\\t\\ttmp = []\\n\\t\\tcols = []\\n\\t\\tcols = sel_string.split(\\\";\\\")\\n\\t\\tfor col in cols:\\n\\t\\t\\tinverse = False\\n\\t\\t\\tif col == \\\"\\\":\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\ttmp = string.split(col, \\\"=\\\")\\n\\t\\t\\tif \\\"!\\\" in tmp[0]:\\n\\t\\t\\t\\tinverse = True\\n\\n\\t\\t\\tif \\\"resi\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseResI(tmp[1])\\n\\t\\t\\t\\tself.invresi = inverse\\n\\t\\t\\telif \\\"resn\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseResN(tmp[1])\\n\\t\\t\\t\\tself.invresn = inverse\\n\\t\\t\\telif \\\"name\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(tmp[1])\\n\\t\\t\\t\\tself.invatom = inverse\\n\\t\\t\\telif \\\"element\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseElement(tmp[1])\\n\\t\\t\\t\\tself.invelement = inverse\\t\\n\\t\\t\\telif \\\"chain\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseChain(tmp[1])\\n\\t\\t\\t\\tself.invchain = inverse\\n\\t\\t\\telif \\\"type\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseType(tmp[1])\\n\\t\\t\\t\\tself.invtype = inverse\\n\\t\\t\\telif \\\"cat\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseCat(tmp[1])\\n\\t\\t\\t\\tself.invcat = inverse\\n\\t\\t\\telif \\\"atomid\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtomid(tmp[1])\\n\\t\\t\\t\\tself.invatomid = inverse\\n\\t\\t\\telif \\\"BB\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O \\\")\\n\\t\\t\\t\\tself.invatom = False\\n\\t\\t\\telif \\\"CEN\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O , CB \\\")\\n\\t\\t\\t\\tself.invatom = False\\n\\t\\t\\telif \\\"SC\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O \\\")\\n\\t\\t\\t\\tself.invatom = True\\n\\t\\t\\telif \\\"HET\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseType(\\\"HETATM\\\")\\n\\t\\t\\t\\tself.invtype = inverse\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint \\\"unrecognized selector: \\\",tmp[0]\\n\\t\\t\\t\\tsys.exit()\",\n \"def choose(self, g, c, p):\\n ng = copy.deepcopy(g)\\n ng[c[0]][c[1]] = p\\n return ng\",\n \"def __init__(self, r=1, p=3):\\n self.p = p\\n self.r = r\",\n \"def _gen_qiskit_gateset(q_circ):\\n return {\\n 'H': q_circ.h,\\n 'X': q_circ.x,\\n 'Y': q_circ.y,\\n 'Z': q_circ.z,\\n 'SWAP': q_circ.swap,\\n 'I': q_circ.iden,\\n 'S': q_circ.s,\\n 'D-S': q_circ.sdg,\\n 'T': q_circ.t,\\n 'D-T': q_circ.tdg,\\n 'RX': q_circ.rx,\\n 'RY': q_circ.ry,\\n 'RZ': q_circ.rz,\\n 'C-H': q_circ.ch,\\n 'CNOT': q_circ.cx,\\n 'C-Y': q_circ.cy,\\n 'CSIGN': q_circ.cz,\\n 'C-RZ': q_circ.crz,\\n 'CCNOT': q_circ.ccx,\\n 'C-SWAP': q_circ.cswap,\\n 'U': q_circ.u3,\\n 'U3': q_circ.u3,\\n 'U2': q_circ.u2,\\n 'U1': q_circ.u1,\\n 'U0': q_circ.iden,\\n 'PH': q_circ.rz,\\n 'RXX': q_circ.rxx,\\n 'RZZ': q_circ.rzz,\\n 'R': q_circ.r,\\n 'MS': q_circ.ms\\n }\",\n \"def selectVertex(self, addToSelection: bool) -> None:\\n ...\",\n \"def new_piece(self):\\n piece_type = pieces.PieceSelector.select_random_piece()\\n return piece_type(game_config.NEXT_PIECE_POSX, game_config.NEXT_PIECE_POSY)\",\n \"def __init__(\\n self, name: str, values: List[Dict], index: Optional[int] = 0,\\n label: Optional[str] = None, help: Optional[str] = None,\\n default: Optional[bool] = None, required: Optional[bool] = False,\\n group: Optional[str] = None\\n ):\\n super(Select, self).__init__(\\n dtype=PARA_SELECT,\\n name=name,\\n index=index,\\n label=label,\\n help=help,\\n default=default,\\n required=required,\\n group=group\\n )\\n self.values = values\",\n \"def touching_choice(self,p):\\n\\n part = ['head', 'foot1', 'foot2', 'foot3', 'foot4', 'back', 'stomach', 'tail']\\n if len(self.select[p]) == 0:\\n return random.sample(part,2)\\n elif len(self.select[p]) == 1:\\n part.remove(self.select[p][0])\\n c = random.sample(part,1)\\n return [self.select[p][0], c[0]]\\n else:\\n return random.sample(self.select[p],2)\",\n \"def select(self):\\n return\",\n \"def __init__(self, pvID, pvP, pvQ, pvDescriptor):\\n\\n # TODO: implement this\",\n \"def upsilons ( self ) :\\n ##\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n ##\\n return self.make_selection (\\n 'Upsilon' ,\\n FilterDesktop , \\n [ self.dimuon () ] , \\n ## algorithm parameters \\n Code = self['UpsilonCut'] ,\\n ## \\n ReFitPVs = True\\n ##\\n )\",\n \"def selection(population: list, weights: list):\\n\\n new_population = list()\\n\\n for individual in population:\\n new_population.append(individual[1])\\n\\n individuals = choices(new_population, weights=weights, k=2)\\n\\n return individuals[0], individuals[1]\",\n \"def generatePDI(self,level='species',type='richness'):\\n if type == 'richness':\\n import biodiversity.richness as rich\\n pdi = rich(self)\\n try:\\n return pdi[level]\\n except:\\n logger.error(\\\"[biospatial.gbif.taxonomy.distanceToTree] level selected non existent (used %s)\\\" %level)\",\n \"def pool_selected( self, object ):\\n\\t\\tud.debug( ud.ADMIN, ud.INFO, 'UVMM.DW.ps(node_uri=%s)' % self.node_uri)\\n\\t\\tpool_name = object.options.get('pool-name')\\n\\t\\tif not pool_name:\\n\\t\\t\\tpool_name = object.options['pool-name'] = 'default'\\n\\t\\tdrive_type = object.options['drive-type']\\n\\t\\ttry:\\n\\t\\t\\tif drive_type == 'cdrom':\\n\\t\\t\\t\\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'cdrom')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'disk' )\\n\\t\\texcept uvmmd.UvmmError, e:\\n\\t\\t\\tvols = ()\\n\\t\\tud.debug(ud.ADMIN, ud.INFO, 'UVMM.DW.ps: volumes=%s' % map(str, vols))\\n\\t\\tchoices = []\\n\\t\\tfor vol in vols:\\n\\t\\t\\tbasename = os.path.basename( vol.source )\\n\\t\\t\\tif '.' in basename:\\n\\t\\t\\t\\tsuffix = basename[ basename.rfind( '.' ) + 1 : ]\\n\\t\\t\\t\\tif suffix in ( 'xml', 'snapshot' ):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\tchoices.append( basename )\\n\\t\\tchoices.sort()\\n\\t\\tself.image_syntax.update_choices( choices )\\n\\n\\t\\t# recreate pool button\\n\\t\\tbtn = self._create_pool_select_button( object.options )\\n\\t\\tself[DriveWizard.PAGE_OLD].options[0] = btn\\n\\t\\tself[DriveWizard.PAGE_NEW].options[0] = btn\\n\\t\\t# recreate driver-type button\\n\\t\\titems = [self[DriveWizard.PAGE_NEW].options[2].id(), self[DriveWizard.PAGE_NEW].options[3].id()]\\n\\t\\tbtn = self._create_type_select_button(object.options, items)\\n\\t\\tself[DriveWizard.PAGE_NEW].options[1] = btn\\n\\n\\t\\tif drive_type == 'disk':\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].hint = None\\n\\t\\telif drive_type in ( 'cdrom', 'floppy' ):\\n\\t\\t\\tif self.image_syntax._choices:\\n\\t\\t\\t\\tmsg = _( \\\"If the required image is not found it might be added by copying the file into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\\\" )\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmsg = _( \\\"The list of available images is empty! To add an image the file needs to be copied into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\\\" )\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].hint = msg\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].description = ''\\n\\t\\telse:\\n\\t\\t\\traise ValueError('Invalid drive-type \\\"%s\\\"' % drive_type)\\n\\n\\t\\treturn self.type_selected(object)\",\n \"def _getAsSelection(self):\\n return self._asSelection\",\n \"def New(*args, **kargs):\\n obj = itkThresholdSegmentationLevelSetImageFilterID2ID2D.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def select_operator(operators, weights, rnd_state):\\n return rnd_state.choice(np.arange(0, len(operators)),\\n p=weights / np.sum(weights))\",\n \"def partition_selection():\\n if selection is None:\\n warning(\\\"You need to pick something first.\\\")\\n return\\n if not selection.obj_type in ['actor','element']:\\n warning(\\\"You need to pick actors or elements.\\\")\\n return\\n for A in GD.canvas.actors:\\n if not A.atype() == 'TriSurface':\\n warning(\\\"Currently I can only partition TriSurfaces.\\\" )\\n return\\n partitionCollection(selection)\\n highlightPartitions(selection)\",\n \"def __init__(self, selected_points, cut_depth, cut_breadth):\\n\\n\\n self.cut_depth = cut_depth\\n self.cut_breadth = cut_breadth\\n\\n self.points = selected_points\\n\\n self.vline = self.vlinecomp()\\n self.hline = self.ortho_line_cut()\\n\\n self.mid_left = self.midpoint(0,1)\\n self.mid_right = self.midpoint(2, 3)\",\n \"def test_non_it(self):\\n self.idx = [9, 11, 6, 10, 12, 2, 8, 1, 5, 0, 7, 4, 3]\\n selector = PCovCUR(n_to_select=12, iterative=False)\\n selector.fit(self.X, self.y)\\n\\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))\",\n \"def getselected_nodes(self):\\n self.selected_nodes = {}\\n for path in self.options.selected_nodes:\\n sel_data = path.rsplit(':', 2)\\n path_id = sel_data[0]\\n sub_path = int(sel_data[1])\\n sel_node = int(sel_data[2])\\n if path_id not in self.selected_nodes:\\n self.selected_nodes[path_id] = {sub_path: [sel_node]}\\n else:\\n if sub_path not in self.selected_nodes[path_id]:\\n self.selected_nodes[path_id][sub_path] = [sel_node]\\n else:\\n self.selected_nodes[path_id][sub_path].extend([sel_node])\",\n \"def get_selection(self, name):\\n print 'hi being selected in plotdata'\\n return self.selections.get(name, None)\",\n \"def __init__(self, cols, center, radius):\\n ColorSelection.__init__(self, cols, center, radius)\",\n \"def pdos_select(self, atoms=None, spin=None, l=None, m=None):\\n valid_m_values = {'s': [],\\n 'p': ['x', 'y', 'z'],\\n 'd': ['xy', 'yz', 'z2-r2', 'xz', 'x2-y2'],\\n 'f': ['y(3x2-y2)', 'xyz', 'yz2', 'z3', 'xz2', 'z(x2-y2)', 'x(x2-3y2)']}\\n if not atoms:\\n atom_idx = list(range(self.number_of_atoms))\\n else:\\n atom_idx = atoms\\n to_return = self.pdos_raw[atom_idx, :, :, :]\\n if not spin:\\n spin_idx = list(range(self.ispin))\\n elif spin == 'up':\\n spin_idx = [0]\\n elif spin == 'down':\\n spin_idx = [1]\\n elif spin == 'both':\\n spin_idx = [0, 1]\\n else:\\n raise ValueError\\n to_return = to_return[:, :, :, spin_idx]\\n\\n if not l:\\n channel_idx = list(range(self.number_of_channels))\\n elif l == 's':\\n channel_idx = [0]\\n elif l == 'p':\\n if not m:\\n channel_idx = [1, 2, 3]\\n else:\\n channel_idx = [1 + i for i, v in enumerate(valid_m_values['p']) if v in m]\\n elif l == 'd':\\n if not m:\\n channel_idx = [4, 5, 6, 7, 8]\\n else:\\n channel_idx = [4 + i for i, v in enumerate(valid_m_values['d']) if v in m]\\n elif l == 'f':\\n if not m:\\n channel_idx = [9, 10, 11, 12, 13, 14, 15]\\n else:\\n channel_idx = [9 + i for i, v in enumerate(valid_m_values['f']) if v in m]\\n else:\\n raise ValueError\\n\\n return to_return[:, :, channel_idx, :]\",\n \"def __init__(self):\\n super().__init__()\\n self.p = 0.0\\n self.type = 'Geometric'\\n self.distType = 'Discrete'\\n self.lowerBound = 0.0\\n self.upperBound = 1.0\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def __init__(self):\\n\\n self.P = list()\\n self.label = 0\",\n \"def selectAdd(op):\\n doc = op.GetDocument()\\n doc.SetActiveObject(op, c4d.SELECTION_ADD)\",\n \"def selection(self):\\n\\n # sort the generation according to fitness.\\n self.sortByFitness()\\n # get the fitness sum.\\n fitnessSum = 0\\n for outfit in self.currentGeneration:\\n fitnessSum += self.applyFitness(outfit)\\n # generate a random number\\n stop = random.uniform(0, 1)\\n accumulated = 0\\n offset = 0\\n for outfit in self.currentGenerationSorted:\\n fitness = self.applyFitness(outfit) + offset\\n probability = fitness / fitnessSum\\n accumulated += probability\\n\\n if stop <= accumulated:\\n return outfit\",\n \"def make_selection(self, num):\\n other_doors = None\\n if num is 1:\\n other_doors = [str(2), str(3)]\\n elif num is 2:\\n other_doors = [str(1), str(3)]\\n elif num is 3:\\n other_doors = [str(1), str(2)]\\n\\n reveal = str(random.choice(other_doors))\\n other_doors.remove(reveal)\\n third_door = random.choice(other_doors)\\n other_doors.remove(third_door)\\n\\n main_door = getattr(self, 'door' + str(num) + '_counter')\\n door_second = getattr(self, 'door' + reveal + '_counter')\\n door_third = getattr(self, 'door' + third_door + '_counter')\\n main_door_reveal = getattr(self, 'door'+str(num)+'_reveal')\\n\\n if (main_door is 0 and door_second is 0\\n and door_third is 0):\\n self.ids['door'+reveal].source = \\\\\\n getattr(self, 'door'+reveal+'_reveal')\\n self.ids['button'+reveal].disabled = True\\n inc = getattr(self, 'door' + str(num) + '_counter')\\n setattr(self, 'door' + str(num) + '_counter', inc + 1)\\n elif main_door is 1 and door_second is 0 and door_third is 0:\\n for i in range(1, 4, 1):\\n self.ids['door' + str(i)].source = \\\\\\n getattr(self, 'door' + str(i) + '_reveal')\\n self.ids['button'+str(i)].disabled = True\\n if main_door_reveal in ['door-money.png']:\\n self.win_popup()\\n else:\\n self.lose_popup()\\n elif main_door is 0 and (door_second is 1 or door_third is 1):\\n for i in range(1, 4, 1):\\n self.ids['door' + str(i)].source = \\\\\\n getattr(self, 'door' + str(i) + '_reveal')\\n self.ids['button'+str(i)].disabled = True\\n if main_door_reveal in ['door-money.png']:\\n self.win_popup()\\n else:\\n self.lose_popup()\",\n \"def survivors_selection(self):\\n q = 5\\n new_population = []\\n for i in range(self._population_size):\\n batch = []\\n for j in range(q):\\n r = random.randint(0, (self._child2population_ratio + 1) * self._population_size - 1)\\n if r < self._population_size:\\n batch.append(self._population[r])\\n else:\\n batch.append(self._children[r - self._population_size])\\n new_population.append(self.select_best(batch))\\n\\n self._population = new_population\",\n \"def selection(self):\\r\\n if not self._selection:\\r\\n print(\\\"not working\\\")\\r\\n return None\\r\\n\\r\\n year, month = self._date.year, self._date.month\\r\\n if len(str(month))==1:\\r\\n month = \\\"0{}\\\".format(month)\\r\\n return (\\\"{}{}{}\\\".format(year, month, self._selection[0]), \\r\\n \\\"{} / {} / {}\\\".format(year, month, self._selection[0]))\",\n \"def selection(self, name):\\n try:\\n return self._selections[name]\\n except KeyError:\\n raise Pype9NameError(\\n \\\"No selection named '{}' (possible '{}')\\\"\\n .format(name, \\\"', '\\\".join(self.selection_names)))\",\n \"def New(*args, **kargs):\\n obj = itkThresholdSegmentationLevelSetImageFilterID3ID3D.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def addSelectedToCanvas(self):\\n\\n selected = self.moduleList.currentItem()\\n module = selected.data(QtCore.Qt.UserRole)[0]\\n\\n index = self.pickerUI.characterTabs.currentIndex()\\n widget = self.pickerUI.characterTabs.widget(index)\\n characterNode = widget.property(\\\"charNode\\\")\\n\\n # get inst\\n modType = cmds.getAttr(module + \\\".moduleType\\\")\\n modName = cmds.getAttr(module + \\\".moduleName\\\")\\n mod = __import__(\\\"RigModules.\\\" + modType, {}, {}, [modType])\\n reload(mod)\\n\\n # get the class name from that module file (returns RigModules.ART_Root.ART_Root for example)\\n moduleClass = getattr(mod, mod.className)\\n\\n # find the instance of that module\\n moduleInst = moduleClass(self, modName)\\n self.modules.append(moduleInst)\\n\\n scene = self.getCurrentCanvasTab()\\n\\n # find out if charNode has a namespace\\n if cmds.objExists(characterNode + \\\".namespace\\\"):\\n namespace = cmds.getAttr(characterNode + \\\".namespace\\\") + \\\":\\\"\\n else:\\n namespace = \\\"\\\"\\n\\n # pass in the network node and the namespace\\n picker = moduleInst.pickerUI(scene.sceneRect().center(), self.pickerUI, module, namespace)\\n scene.addItem(picker[0])\\n self.pickerUI.selectionScriptJobs.append(picker[2])\\n\\n # =======================================================================\\n # #mirror the module's pickerBorderItem if needed\\n # =======================================================================\\n if picker[1] == True:\\n picker[0].setTransformOriginPoint(picker[0].boundingRect().center())\\n picker[0].setTransform(QtGui.QTransform(-1.0, 0.0, 0.0, 1.0, picker[0].boundingRect().width() * 2, 0.0))\\n\\n children = picker[0].childItems()\\n if children is not None:\\n self.mirrorChildren(children)\\n\\n row = self.moduleList.row(selected)\\n self.moduleList.takeItem(row)\",\n \"def choices(symbols, k):\\n return [R.choice(symbols) for _ in range(k)]\",\n \"def __call__(self) -> abjad.Selection:\\n if (self._repetition_chance == 0.0\\n or random.random() > self._repetition_chance):\\n if not self._is_first_window or self._process_on_first_call:\\n if self._mode == 'out':\\n self._remove_element()\\n else:\\n self._add_element()\\n elif not self._include_empty_measures and self._mode == 'in':\\n self._add_element()\\n self._mask_to_selection()\\n return self.current_window\",\n \"def pi(self):\\n return self(self._real_field().pi())\",\n \"def select(self, test):\\n survivors = []\\n for particle in self.particles:\\n # Find the originating particle\\n parent = particle\\n while parent.origin is not None:\\n parent = parent.origin.initial_state[0]\\n if test(parent, particle) is True:\\n survivors.append(particle)\\n return ParticleCollection(survivors)\",\n \"def __init__(self, k=1):\\n self.k = k\\n self.x = None\\n self.y = None\\n self.classes_ = None\",\n \"def pick(self):\\n\\n pickerdict = {}\\n current_value = 0\\n\\n if len(self.choices) == 0:\\n return None\\n\\n if len(self.choices) == 1:\\n return self.choices[0][0]\\n\\n for option in self.choices:\\n pickerdict[current_value] = option[0]\\n current_value += option[1]\\n\\n picker = random.randint(0, current_value)\\n last_value = 0\\n result = None\\n sorted_keys = sorted(pickerdict.keys())\\n\\n found = False\\n for key in sorted_keys:\\n if key >= picker:\\n result = pickerdict[last_value]\\n found = True\\n continue\\n last_value = key\\n\\n if not found:\\n result = pickerdict[sorted_keys[-1]]\\n\\n return result\",\n \"def __init__(self, r1=4.5*0.0254, r2=4.5*0.0254,\\n d1=25.0*0.0254, d2=25.0*0.0254,\\n Ixx=185000.0*0.45359237*0.0254**2,\\n Iyy=185000.0*0.45359237*0.0254**2,\\n Izz=3500.0*0.45359237*0.0254**2,):\\n self.r1 = r1 # m\\n self.r2 = r2 # m\\n self.d1 = d1 # m\\n self.d2 = d2 # m\\n self.Ixx = Ixx # kg-m^2\\n self.Iyy = Iyy # kg-m^2\\n self.Izz = Izz # kg-m^2\",\n \"def _write_selec(parameters):\\n # Load data\\n from ._common import selections\\n\\n data = deepcopy(selections)\\n if parameters[\\\"selections\\\"][\\\"integers\\\"]:\\n data[\\\"integers\\\"].update(parameters[\\\"selections\\\"][\\\"integers\\\"])\\n if len(parameters[\\\"selections\\\"][\\\"floats\\\"]):\\n data[\\\"floats\\\"] = parameters[\\\"selections\\\"][\\\"floats\\\"]\\n\\n # Check floats and overwrite IE(1)\\n if data[\\\"floats\\\"] is not None and len(data[\\\"floats\\\"]):\\n if isinstance(data[\\\"floats\\\"][0], (list, tuple, numpy.ndarray)):\\n for x in data[\\\"floats\\\"]:\\n if len(x) > 8:\\n raise ValueError()\\n\\n data[\\\"integers\\\"][1] = len(data[\\\"floats\\\"])\\n ndim = 2\\n\\n else:\\n if len(data[\\\"floats\\\"]) > 8:\\n raise ValueError()\\n\\n data[\\\"integers\\\"][1] = 1\\n ndim = 1\\n else:\\n ndim = None\\n\\n # Formats\\n fmt = block_to_format[\\\"SELEC\\\"]\\n fmt1 = str2format(fmt[1])\\n fmt2 = str2format(fmt[2])\\n\\n # Record 1\\n values = [data[\\\"integers\\\"][k] for k in sorted(data[\\\"integers\\\"].keys())]\\n out = write_record(values, fmt1)\\n\\n # Record 2\\n if ndim == 1:\\n out += write_record(data[\\\"floats\\\"], fmt2)\\n elif ndim == 2:\\n for x in data[\\\"floats\\\"]:\\n out += write_record(x, fmt2)\\n\\n return out\",\n \"def ImagePointPicker(img, pts = 4, **kwargs):\\n\\timgpicker = __ImgPicker(img, pts, **kwargs)\\n\\treturn imgpicker.pickedPoints\",\n \"def pairing_group_create(curve='MNT224'):\\n return PairingGroup(curve)\",\n \"def _selection(self, evaluations, selection, method=\\\"truncated\\\", best_rate=0.2):\\n\\n if selection:\\n end_range_for_parents = max(1, int(self.population_size * best_rate))\\n evaluations_sorted = torch.sort(evaluations)\\n population_sorted = self.population[evaluations_sorted[1]]\\n\\n if self.best_individual is None:\\n self.best_individual = population_sorted[0]\\n self.best_eval = evaluations_sorted[0][0]\\n elif self.best_eval > evaluations_sorted[0][0]:\\n self.best_individual = population_sorted[0]\\n self.best_eval = evaluations_sorted[0][0]\\n best_population = torch.zeros([end_range_for_parents, len(self.population[0])], device=self.device)\\n if method == \\\"truncated\\\":\\n \\\"\\\"\\\"\\n returns best individuals\\n \\\"\\\"\\\"\\n best_population = population_sorted[:end_range_for_parents]\\n elif method == \\\"fitness_based\\\":\\n \\\"\\\"\\\"\\n probability of each individual to be selected is proportional to its fitness value\\n \\\"\\\"\\\"\\n tot = sum(evaluations)\\n probabilities = evaluations / tot\\n for i in range(end_range_for_parents):\\n best_idx = torch.distributions.categorical.Categorical(\\n probabilities.clone().detach()).sample()\\n best_population[i] = self.population[best_idx]\\n # avoid repetitions\\n probabilities[best_idx] = 0\\n elif method == \\\"rank_based\\\":\\n \\\"\\\"\\\"\\n probability of each individual to be selected is proportional to its rank value\\n \\\"\\\"\\\"\\n tot = ((1 + len(evaluations)) / 2) * len(evaluations)\\n ranks = torch.linspace(1, len(evaluations), steps=len(evaluations), device=self.device)\\n sorted_probabilities = 1 - ranks / tot\\n for i in range(end_range_for_parents):\\n best_idx = torch.distributions.categorical.Categorical(\\n sorted_probabilities).sample()\\n best_population[i] = population_sorted[best_idx]\\n # avoid repetitions\\n sorted_probabilities[best_idx] = 0\\n if self.elitism:\\n best_population[end_range_for_parents - 1] = self.best_individual\\n else:\\n best_population = self.population\\n return best_population\",\n \"def legalize_Select(optree):\\n cond = optree.get_input(0)\\n op0 = optree.get_input(1)\\n op1 = optree.get_input(2)\\n precision = optree.get_precision()\\n if precision is None:\\n Log.report(Log.Error, \\\"None precision for Select:\\\\n{}\\\", optree)\\n if op0.get_precision().get_bit_size() != precision.get_bit_size():\\n optree.set_input(\\n 1,\\n Conversion(\\n op0,\\n precision = precision\\n )\\n )\\n if op1.get_precision().get_bit_size() != precision.get_bit_size():\\n optree.set_input(\\n 2,\\n Conversion(\\n op1,\\n precision = optree.get_precision()\\n )\\n )\\n return optree\",\n \"def pkj1pk(self,r,z=0):\\n return M.sqrt(M.pi/2.0)/r*self.besselInt.besselInt(lambda k: self.delta(k/r, z)/M.sqrt(k),1.5,self.besselN,self.besselh)\",\n \"def get_computers_choice():\\n choices = ['Rock', 'Paper', 'Scissors']\\n choice_index = randint(0, 2)\\n choice = choices[choice_index]\\n return choice\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.656367","0.60201555","0.57468003","0.55250317","0.55029947","0.54665506","0.53652567","0.5354767","0.5222274","0.52220505","0.51531583","0.51516193","0.5116602","0.50792444","0.5024644","0.5015439","0.5015241","0.49948704","0.49836156","0.49750015","0.4951771","0.49449685","0.4906584","0.48983282","0.48919162","0.4881866","0.48805493","0.48796737","0.4878966","0.4870896","0.4869406","0.48576924","0.48564172","0.48269144","0.48269144","0.48207635","0.4819919","0.48023215","0.4798266","0.47969383","0.4794351","0.47862366","0.47808602","0.47808602","0.47808602","0.47808602","0.47808602","0.47808602","0.47808602","0.47808602","0.47808602","0.47753075","0.47624794","0.47552288","0.47283903","0.47145227","0.4709548","0.4709375","0.47060424","0.4697647","0.46929917","0.4691896","0.46908948","0.46864256","0.4680707","0.46544144","0.4650397","0.46420047","0.4638613","0.46379852","0.46322453","0.46207172","0.46131504","0.46101162","0.4609979","0.46062496","0.46039546","0.45991406","0.45958832","0.4595597","0.45926937","0.45913664","0.4581859","0.45817038","0.4581605","0.45802715","0.4577448","0.45723152","0.45706654","0.4566401","0.45637488","0.45570725","0.45476562","0.45474976","0.45405734","0.45391718","0.45374203","0.45328453","0.45306256","0.45269525","0.45229387"],"string":"[\n \"0.656367\",\n \"0.60201555\",\n \"0.57468003\",\n \"0.55250317\",\n \"0.55029947\",\n \"0.54665506\",\n \"0.53652567\",\n \"0.5354767\",\n \"0.5222274\",\n \"0.52220505\",\n \"0.51531583\",\n \"0.51516193\",\n \"0.5116602\",\n \"0.50792444\",\n \"0.5024644\",\n \"0.5015439\",\n \"0.5015241\",\n \"0.49948704\",\n \"0.49836156\",\n \"0.49750015\",\n \"0.4951771\",\n \"0.49449685\",\n \"0.4906584\",\n \"0.48983282\",\n \"0.48919162\",\n \"0.4881866\",\n \"0.48805493\",\n \"0.48796737\",\n \"0.4878966\",\n \"0.4870896\",\n \"0.4869406\",\n \"0.48576924\",\n \"0.48564172\",\n \"0.48269144\",\n \"0.48269144\",\n \"0.48207635\",\n \"0.4819919\",\n \"0.48023215\",\n \"0.4798266\",\n \"0.47969383\",\n \"0.4794351\",\n \"0.47862366\",\n \"0.47808602\",\n \"0.47808602\",\n \"0.47808602\",\n \"0.47808602\",\n \"0.47808602\",\n \"0.47808602\",\n \"0.47808602\",\n \"0.47808602\",\n \"0.47808602\",\n \"0.47753075\",\n \"0.47624794\",\n \"0.47552288\",\n \"0.47283903\",\n \"0.47145227\",\n \"0.4709548\",\n \"0.4709375\",\n \"0.47060424\",\n \"0.4697647\",\n \"0.46929917\",\n \"0.4691896\",\n \"0.46908948\",\n \"0.46864256\",\n \"0.4680707\",\n \"0.46544144\",\n \"0.4650397\",\n \"0.46420047\",\n \"0.4638613\",\n \"0.46379852\",\n \"0.46322453\",\n \"0.46207172\",\n \"0.46131504\",\n \"0.46101162\",\n \"0.4609979\",\n \"0.46062496\",\n \"0.46039546\",\n \"0.45991406\",\n \"0.45958832\",\n \"0.4595597\",\n \"0.45926937\",\n \"0.45913664\",\n \"0.4581859\",\n \"0.45817038\",\n \"0.4581605\",\n \"0.45802715\",\n \"0.4577448\",\n \"0.45723152\",\n \"0.45706654\",\n \"0.4566401\",\n \"0.45637488\",\n \"0.45570725\",\n \"0.45476562\",\n \"0.45474976\",\n \"0.45405734\",\n \"0.45391718\",\n \"0.45374203\",\n \"0.45328453\",\n \"0.45306256\",\n \"0.45269525\",\n \"0.45229387\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7395,"cells":{"query":{"kind":"string","value":"Create and return a D+ > D pi+ Selection object."},"document":{"kind":"string","value":"def makeDstarPartial( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\n #\n ## check existing selection\n #\n sel = self._selection ( sel_tag )\n if sel : return sel \n\n #\n ## adjust a bit the arguments\n if not kwargs.has_key('Preambulo') :\n kwargs ['Preambulo' ] = self['Preambulo']\n\n if not kwargs.has_key( 'ParticleCombiners' ) :\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \n \n # \n ## use \"simple-selection\"\n #\n from PhysSelPython.Wrappers import SimpleSelection\n sel = SimpleSelection (\n sel_name ,\n algotype ,\n inputs , \n *args ,\n **kwargs )\n # \n return self._add_selection( sel_tag , sel )","def from_selection(cls):\n guid = compas_rhino.select_point()\n return cls.from_guid(guid)","def makeDstar2D0Pi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )","def create(cls, selection):\n\t\t\n\t\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })","def get_selection():\n\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\n sel_len = len(selected)\n result = SelectionContainer()\n\n for _x in range(0, sel_len):\n\n shape_type = selected[_x].ShapeType\n\n if shape_type == 'Vertex':\n result.vertices.append(selected[_x])\n\n elif shape_type == 'Edge':\n\n if 'Line' in str(selected[_x].Curve):\n result.lines.append(selected[_x])\n else:\n result.curves.append(selected[_x])","def curve_through_selection(*args):\n sel = cmds.ls(sl=True, fl=True)\n if not sel or len(sel)==1:\n cmds.warning(\"You need to select multiple things to create curve through!\")\n return()\n\n pList = []\n crvType = cmds.radioButtonGrp(widgets[\"crvSelRBG\"], q=True, sl=True)\n\n for obj in sel:\n if cmds.objectType(obj) in [\"transform\"]:\n pos = cmds.xform(obj, q=True, ws=True, rp=True)\n pList.append(pos)\n elif obj in cmds.filterExpand(sm=[28, 30, 31, 32, 34, 46]):\n pos = cmds.pointPosition(obj)\n pList.append(pos)\n\n #add points if only 2 (cv, ep) or 3 (cv) are given, and create the curve\n if crvType == 1:\n if len(pList) == 2:\n f = [float(sum(x)/2) for x in zip(*pList)]\n pList.insert(1, f)\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\n pList.insert(1, newPt1)\n pList.insert(3, newPt2)\n if len(pList) == 3:\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\n pList.insert(1, newPt1)\n pList.insert(3, newPt2)\n crv = cmds.curve(d=3, p=pList, name=\"newCurve\")\n\n if crvType == 2:\n if len(pList) == 2:\n f = [float(sum(x)/2) for x in zip(*pList)]\n pList.insert(1, f)\n crv = cmds.curve(d=3, ep=pList, name=\"newCurve\")\n\n return(crv)","def selectAdd(op):\n doc = op.GetDocument()\n doc.SetActiveObject(op, c4d.SELECTION_ADD)","def get_gold_selection(self, pointer):\n raise NotImplementedError","def makePseudoPsi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n _daugCuts = \"(PT> %(D0PtLoose)s*MeV)\" % locals()['config']\n _combCuts = \"(APT> %(D0PtLoose)s*MeV)\" % locals()['config']\n\n _Psi = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"D0\": _daugCuts }\n , CombinationCut = _combCuts\n , MotherCut = \"(VFASPF(VCHI2PDOF) < 10000)\"\n )\n\n return Selection( name+'Sel',\n Algorithm = _Psi,\n RequiredSelections = inputSel\n )","def selectVertex(self, addToSelection: bool) -> None:\n ...","def createSelector(self,type='select',speed=2.0):\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector.hide()\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def createSelector2(self,type='select',speed=2.0):\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector2.hide()\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def makeSelection(self, selection=\"\"):\n\n\t\tif selection == \"\":\n\t\t\tprint \"usage: makeSelection(selection)\"\n\n\t\tsel_string = self.parseMacros(selection)\n\n\t\t# --- split by \";\" --- #\n\t\ttmp = []\n\t\tcols = []\n\t\tcols = sel_string.split(\";\")\n\t\tfor col in cols:\n\t\t\tinverse = False\n\t\t\tif col == \"\":\n\t\t\t\tcontinue\n\n\t\t\ttmp = string.split(col, \"=\")\n\t\t\tif \"!\" in tmp[0]:\n\t\t\t\tinverse = True\n\n\t\t\tif \"resi\" in tmp[0]:\n\t\t\t\tself.parseResI(tmp[1])\n\t\t\t\tself.invresi = inverse\n\t\t\telif \"resn\" in tmp[0]:\n\t\t\t\tself.parseResN(tmp[1])\n\t\t\t\tself.invresn = inverse\n\t\t\telif \"name\" in tmp[0]:\n\t\t\t\tself.parseAtom(tmp[1])\n\t\t\t\tself.invatom = inverse\n\t\t\telif \"element\" in tmp[0]:\n\t\t\t\tself.parseElement(tmp[1])\n\t\t\t\tself.invelement = inverse\t\n\t\t\telif \"chain\" in tmp[0]:\n\t\t\t\tself.parseChain(tmp[1])\n\t\t\t\tself.invchain = inverse\n\t\t\telif \"type\" in tmp[0]:\n\t\t\t\tself.parseType(tmp[1])\n\t\t\t\tself.invtype = inverse\n\t\t\telif \"cat\" in tmp[0]:\n\t\t\t\tself.parseCat(tmp[1])\n\t\t\t\tself.invcat = inverse\n\t\t\telif \"atomid\" in tmp[0]:\n\t\t\t\tself.parseAtomid(tmp[1])\n\t\t\t\tself.invatomid = inverse\n\t\t\telif \"BB\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O \")\n\t\t\t\tself.invatom = False\n\t\t\telif \"CEN\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O , CB \")\n\t\t\t\tself.invatom = False\n\t\t\telif \"SC\" in tmp[0]:\n\t\t\t\tself.parseAtom(\" N , CA , C , O \")\n\t\t\t\tself.invatom = True\n\t\t\telif \"HET\" in tmp[0]:\n\t\t\t\tself.parseType(\"HETATM\")\n\t\t\t\tself.invtype = inverse\n\t\t\telse:\n\t\t\t\tprint \"unrecognized selector: \",tmp[0]\n\t\t\t\tsys.exit()","def 选择项目(self, n): # real signature unknown; restored from __doc__\n return self.Select(n)","def _add_selection ( self , nick , sel ) :\n if not self.__selections_.has_key ( self.name() ) :\n self.__selections_[ self.name() ] = {} \n \n if self.__selections_[ self.name()].has_key( nick ) :\n raise AttributeError , \"Selection '%s'already exists \" % nick\n \n self.__selections_[ self.name() ][ nick ] = sel\n \n return sel","def selectAdd(node):\n node['selected'].setValue(True)","def from_selection(\n class_,\n selection,\n item_class=None,\n ):\n import abjad\n pitch_segment = abjad.PitchSegment.from_selection(selection)\n return class_(\n pitch_segment,\n item_class=item_class,\n )","def makeDefault(name,inputSel) :\n from Configurables import OfflineVertexFitter\n Detached4mu = CombineParticles(\"Combine\"+name)\n Detached4mu.DecayDescriptor = \"B_s0 -> mu+ mu- mu+ mu-\"\n # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:\n Detached4mu.addTool( OfflineVertexFitter )\n Detached4mu.ParticleCombiners.update( { \"\" : \"OfflineVertexFitter\"} )\n Detached4mu.OfflineVertexFitter.useResonanceVertex = False\n Detached4mu.ReFitPVs = True\n Detached4mu.DaughtersCuts = { \"mu+\" : \"(TRCHI2DOF < 2.5 ) \"\\\n \" & (MIPCHI2DV(PRIMARY)> 9.)\"}\n \n Detached4mu.CombinationCut = \"(ADAMASS('B_s0')<1000*MeV) \"\\\n \"& (AMAXDOCA('')<0.3*mm)\"\n Detached4mu.MotherCut = \"(VFASPF(VCHI2/VDOF)<9) \"\\\n \"& (BPVDIRA > 0) \"\\\n \"& (BPVVDCHI2>100)\"\\\n \" & (M>4366.3) & (M<6366.3)\"\\\n \"& (BPVIPCHI2()< 25) \"\n \n\n return Selection (name,\n Algorithm = Detached4mu,\n RequiredSelections = inputSel)","def instantiateNewCmd(self):\n return QadGRIPSTRETCHCommandClass(self.plugIn)","def add_new_to_sel(self):\n self.parent().do_new(keep_sel=True)","def make_odorant_selector(name):\n return dcc.Input(\n id=\"cid_%s\" % name,\n placeholder=\"Enter a PubChem ID number...\",\n type=\"number\",\n value=None,\n )","def __init__(self, parent):\n # parent is the main frame of PyCorrFit\n self.parent = parent\n ## MYID\n # This ID is given by the parent for an instance of this class\n self.MyID = None\n ## Wrapping\n curvedict, labels = self.GetCurvedict()\n self.labels = labels\n self.Selector = UserSelectCurves(parent, curvedict,\n wrapper=self, labels=labels)\n # This is necessary for parent to deselect and select the tool\n # in the tools menu.\n self.Bind = self.Selector.Bind\n if self.parent.notebook.GetPageCount() == 0:\n self.Selector.sp.Disable()","def addSelectedToCanvas(self):\n\n selected = self.moduleList.currentItem()\n module = selected.data(QtCore.Qt.UserRole)[0]\n\n index = self.pickerUI.characterTabs.currentIndex()\n widget = self.pickerUI.characterTabs.widget(index)\n characterNode = widget.property(\"charNode\")\n\n # get inst\n modType = cmds.getAttr(module + \".moduleType\")\n modName = cmds.getAttr(module + \".moduleName\")\n mod = __import__(\"RigModules.\" + modType, {}, {}, [modType])\n reload(mod)\n\n # get the class name from that module file (returns RigModules.ART_Root.ART_Root for example)\n moduleClass = getattr(mod, mod.className)\n\n # find the instance of that module\n moduleInst = moduleClass(self, modName)\n self.modules.append(moduleInst)\n\n scene = self.getCurrentCanvasTab()\n\n # find out if charNode has a namespace\n if cmds.objExists(characterNode + \".namespace\"):\n namespace = cmds.getAttr(characterNode + \".namespace\") + \":\"\n else:\n namespace = \"\"\n\n # pass in the network node and the namespace\n picker = moduleInst.pickerUI(scene.sceneRect().center(), self.pickerUI, module, namespace)\n scene.addItem(picker[0])\n self.pickerUI.selectionScriptJobs.append(picker[2])\n\n # =======================================================================\n # #mirror the module's pickerBorderItem if needed\n # =======================================================================\n if picker[1] == True:\n picker[0].setTransformOriginPoint(picker[0].boundingRect().center())\n picker[0].setTransform(QtGui.QTransform(-1.0, 0.0, 0.0, 1.0, picker[0].boundingRect().width() * 2, 0.0))\n\n children = picker[0].childItems()\n if children is not None:\n self.mirrorChildren(children)\n\n row = self.moduleList.row(selected)\n self.moduleList.takeItem(row)","def select(*args, add: bool=True, addFirst: bool=True, all: bool=True, allDagObjects: bool=True,\n allDependencyNodes: bool=True, clear: bool=True, containerCentric: bool=True,\n deselect: bool=True, hierarchy: bool=True, noExpand: bool=True, replace: bool=True,\n symmetry: bool=True, symmetrySide: int=0, toggle: bool=True, visible: bool=True,\n **kwargs)->None:\n pass","def select(self):\n\n return self.p[0], self.p[1]","def db(r):\n ey = gQ(r)\n gR = b.tcl(\n 'global no_gizmo; set no_gizmo 1; in %s {%s -New} ; return [value [stack 0].name]' % (ey.fullName(), r.Class()))\n group = b.toNode('.'.join((ey.fullName(), gR)))\n group.setSelected(False)\n if ew(r):\n for node, gS in ew(r).iteritems():\n for c in gS:\n node.setInput(c, group)\n\n for c in range(r.inputs()):\n group.setInput(c, r.input(c))\n\n group.setXYpos(r.xpos(), r.ypos())\n group.readKnobs(r.writeKnobs(b.TO_SCRIPT))\n b.delete(r)\n return group","def pass_selection_dR(self, dR):\n dR_max = self.cut_dict[self.sample_name][\"dR_cut\"]\n return self.pass_selection_val(val=dR, val_max=dR_max)","def generate_kdtree(self):\n if self.method==2:\n coordinates = self.unassigned_data[0:3,:]\n else:\n coordinates = self.unassigned_data[0:2,:]\n tree = cKDTree(coordinates.T)\n\n return tree","def make_selection(self, num):\n other_doors = None\n if num is 1:\n other_doors = [str(2), str(3)]\n elif num is 2:\n other_doors = [str(1), str(3)]\n elif num is 3:\n other_doors = [str(1), str(2)]\n\n reveal = str(random.choice(other_doors))\n other_doors.remove(reveal)\n third_door = random.choice(other_doors)\n other_doors.remove(third_door)\n\n main_door = getattr(self, 'door' + str(num) + '_counter')\n door_second = getattr(self, 'door' + reveal + '_counter')\n door_third = getattr(self, 'door' + third_door + '_counter')\n main_door_reveal = getattr(self, 'door'+str(num)+'_reveal')\n\n if (main_door is 0 and door_second is 0\n and door_third is 0):\n self.ids['door'+reveal].source = \\\n getattr(self, 'door'+reveal+'_reveal')\n self.ids['button'+reveal].disabled = True\n inc = getattr(self, 'door' + str(num) + '_counter')\n setattr(self, 'door' + str(num) + '_counter', inc + 1)\n elif main_door is 1 and door_second is 0 and door_third is 0:\n for i in range(1, 4, 1):\n self.ids['door' + str(i)].source = \\\n getattr(self, 'door' + str(i) + '_reveal')\n self.ids['button'+str(i)].disabled = True\n if main_door_reveal in ['door-money.png']:\n self.win_popup()\n else:\n self.lose_popup()\n elif main_door is 0 and (door_second is 1 or door_third is 1):\n for i in range(1, 4, 1):\n self.ids['door' + str(i)].source = \\\n getattr(self, 'door' + str(i) + '_reveal')\n self.ids['button'+str(i)].disabled = True\n if main_door_reveal in ['door-money.png']:\n self.win_popup()\n else:\n self.lose_popup()","def get_selection(self, selection_name, format=None):","def __call__(self) -> abjad.Selection:\n if (self._repetition_chance == 0.0\n or random.random() > self._repetition_chance):\n if not self._is_first_window or self._process_on_first_call:\n if self._mode == 'out':\n self._remove_element()\n else:\n self._add_element()\n elif not self._include_empty_measures and self._mode == 'in':\n self._add_element()\n self._mask_to_selection()\n return self.current_window","def polySelect(*args, add: bool=True, addFirst: bool=True, asSelectString: bool=True, deselect:\n bool=True, edgeBorder: Union[int, List[int], bool]=0, edgeBorderPath:\n Union[List[int, int], List[List[int, int]], bool]=None, edgeBorderPattern:\n Union[List[int, int], List[List[int, int]], bool]=None, edgeLoop: Union[int,\n List[int], bool]=0, edgeLoopOrBorder: Union[int, List[int], bool]=0,\n edgeLoopOrBorderPattern: Union[List[int, int], List[List[int, int]], bool]=None,\n edgeLoopPath: Union[List[int, int], List[List[int, int]], bool]=None,\n edgeLoopPattern: Union[List[int, int], List[List[int, int]], bool]=None,\n edgeRing: Union[int, List[int], bool]=0, edgeRingPath: Union[List[int, int],\n List[List[int, int]], bool]=None, edgeRingPattern: Union[List[int, int],\n List[List[int, int]], bool]=None, edgeUVLoopOrBorder: Union[int, List[int],\n bool]=0, everyN: int=0, extendToShell: Union[int, List[int], bool]=0,\n noSelection: bool=True, replace: bool=True, shortestEdgePath: Union[List[int,\n int], List[List[int, int]], bool]=None, shortestEdgePathUV: Union[List[int, int],\n List[List[int, int]], bool]=None, shortestFacePath: Union[List[int, int],\n List[List[int, int]], bool]=None, toggle: bool=True, q=True, query=True,\n **kwargs)->Union[List[int], Any]:\n pass","def selection(self):\n # create an empty priority queue for the new generation\n newGeneration = PriorityQueue()\n # pick top X of the population to survive\n for c in range(0, self.generation.qsize() / SELECTION_FRACTION):\n # get a chromosome\n chromosome = self.generation.get()\n # put the chromosomes in the new generation\n newGeneration.put(chromosome)\n # keep the new generation\n self.generation = newGeneration","def new_piece(self):\n piece_type = pieces.PieceSelector.select_random_piece()\n return piece_type(game_config.NEXT_PIECE_POSX, game_config.NEXT_PIECE_POSY)","def project(record, selected, pkey_name) -> StateDictInterface:\n if selected:\n keys = set(selected.keys()) | {pkey_name}\n return record.projection(keys)\n else:\n return record","def from_selection(cls):\n guid = compas_rhino.select_mesh()\n return cls.from_guid(guid)","def select(self):\n\t\tbest_num_components = self.n_constant\n\t\treturn self.base_model(best_num_components)","def select(self):\n pass","def select(self):\n pass","def get_next_gp(self):\n next_gp = self.gpf_core.get_next_gp()[2]\n next_gp.build_posterior()\n return DragonflyGP(next_gp, self.options)","def newDragBtn(self, color, selected, name, parent, width, height, tabIndex):\n btn = drag.DragButton(color, selected, self, name ) #create new draggable button\n btn.setParent(parent)\n btn.resize(width, height)\n btn.show() #show button\n logger.info(\"new button: %s\" % name)\n\n #add to objects dictionary\n if selected != None:\n for i in selected:\n if(i in self.objects[tabIndex]):\n self.objects[tabIndex][str(i)].append(btn) #add to array of buttons\n else:\n self.objects[tabIndex][str(i)]=[btn] #create array of buttons\n logger.debug(self.objects)\n else:\n logger.error(\"nothing is being connected to button\")\n\n return btn","def select(self, new_pop, new_vals):\n raise NotImplemented(\n \"Method `EvolutionaryAlgorithm.select` should be implemented in subclasses!\")","def instantiateNewCmd(self):\n return QadSTRETCHCommandClass(self.plugIn)","def create_gui(self):\n\n selectors_widgets = list()\n\n for n in range(4):\n\n selectors_widgets.append(wd.Dropdown(\n options={'': 0, 'Orange': 1, 'Red': 2, 'Blue': 3, 'Green': 4},\n value=0,\n disabled=False,\n layout={'width': '148px'}\n ))\n\n self.confirm_button.on_click(\n self.create_combination_and_rate_function())\n self.user_interact.children = [self.selectors, self.confirm_button]\n\n self.selectors.children = selectors_widgets","def to_pda(self) -> \"pda.PDA\":\n state = pda.State(\"q\")\n pda_object_creator = PDAObjectCreator(self._terminals, self._variables)\n input_symbols = {pda_object_creator.get_symbol_from(x)\n for x in self._terminals}\n stack_alphabet = {pda_object_creator.get_stack_symbol_from(x)\n for x in self._terminals.union(self._variables)}\n start_stack_symbol = pda_object_creator.get_stack_symbol_from(\n self._start_symbol)\n new_pda = pda.PDA(states={state},\n input_symbols=input_symbols,\n stack_alphabet=stack_alphabet,\n start_state=state,\n start_stack_symbol=start_stack_symbol)\n for production in self._productions:\n new_pda.add_transition(state, pda.Epsilon(),\n pda_object_creator.get_stack_symbol_from(\n production.head),\n state,\n [pda_object_creator.get_stack_symbol_from(x)\n for x in production.body])\n for terminal in self._terminals:\n new_pda.add_transition(state,\n pda_object_creator.get_symbol_from(\n terminal),\n pda_object_creator.get_stack_symbol_from(\n terminal),\n state, [])\n return new_pda","def _create_features_dropdown(self, name=_features_dropdown):\n fts = sorted(self.features)\n d = Select(options=fts, css_classes=[self._features_dropdown], name=name)\n return d","def _getAsSelection(self):\n return self._asSelection","def softSelect(*args, compressUndo: Union[int, bool]=0, enableFalseColor: Union[int, bool]=0,\n softSelectColorCurve: Union[AnyStr, bool]=\"\", softSelectCurve: Union[AnyStr,\n bool]=\"\", softSelectDistance: Union[float, bool]=0.0, softSelectEnabled:\n Union[int, bool]=0, softSelectFalloff: Union[int, bool]=0, softSelectReset:\n bool=True, softSelectUVDistance: Union[float, bool]=0.0, q=True, query=True,\n e=True, edit=True, **kwargs)->Union[None, Any]:\n pass","def select(self):\r\n pass","def createGraphPoint(self, cls, newId):\n def getUniqueId(container, base):\n ids = set(container.objectIds())\n new = base\n i = 2\n while new in ids:\n new = '%s%s' % (base, i)\n i += 1\n return new\n newId = getUniqueId(self.graphPoints, newId)\n gp = cls(newId)\n # Set sequence\n if gp.isThreshold:\n gp.sequence = -1\n else:\n gp.sequence = len(self.graphPoints())\n # Set legend for graph points on multigraph reports\n if self.report() and hasattr(gp, 'legend'):\n # For MultiGraphReports we use a fancier legend\n # to differentiate when you have multiple devices/graphpoints\n # on a single graph\n gp.legend = gp.DEFAULT_MULTIGRAPH_LEGEND\n self.graphPoints._setObject(gp.id, gp)\n gp = self.graphPoints._getOb(gp.id)\n if gp.sequence == -1:\n self.manage_resequenceGraphPoints()\n return gp","def __init__(self, pvID, pvP, pvQ, pvDescriptor):\n\n # TODO: implement this","def pool_selected( self, object ):\n\t\tud.debug( ud.ADMIN, ud.INFO, 'UVMM.DW.ps(node_uri=%s)' % self.node_uri)\n\t\tpool_name = object.options.get('pool-name')\n\t\tif not pool_name:\n\t\t\tpool_name = object.options['pool-name'] = 'default'\n\t\tdrive_type = object.options['drive-type']\n\t\ttry:\n\t\t\tif drive_type == 'cdrom':\n\t\t\t\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'cdrom')\n\t\t\telse:\n\t\t\t\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'disk' )\n\t\texcept uvmmd.UvmmError, e:\n\t\t\tvols = ()\n\t\tud.debug(ud.ADMIN, ud.INFO, 'UVMM.DW.ps: volumes=%s' % map(str, vols))\n\t\tchoices = []\n\t\tfor vol in vols:\n\t\t\tbasename = os.path.basename( vol.source )\n\t\t\tif '.' in basename:\n\t\t\t\tsuffix = basename[ basename.rfind( '.' ) + 1 : ]\n\t\t\t\tif suffix in ( 'xml', 'snapshot' ):\n\t\t\t\t\tcontinue\n\t\t\tchoices.append( basename )\n\t\tchoices.sort()\n\t\tself.image_syntax.update_choices( choices )\n\n\t\t# recreate pool button\n\t\tbtn = self._create_pool_select_button( object.options )\n\t\tself[DriveWizard.PAGE_OLD].options[0] = btn\n\t\tself[DriveWizard.PAGE_NEW].options[0] = btn\n\t\t# recreate driver-type button\n\t\titems = [self[DriveWizard.PAGE_NEW].options[2].id(), self[DriveWizard.PAGE_NEW].options[3].id()]\n\t\tbtn = self._create_type_select_button(object.options, items)\n\t\tself[DriveWizard.PAGE_NEW].options[1] = btn\n\n\t\tif drive_type == 'disk':\n\t\t\tself[DriveWizard.PAGE_OLD].hint = None\n\t\telif drive_type in ( 'cdrom', 'floppy' ):\n\t\t\tif self.image_syntax._choices:\n\t\t\t\tmsg = _( \"If the required image is not found it might be added by copying the file into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\" )\n\t\t\telse:\n\t\t\t\tmsg = _( \"The list of available images is empty! To add an image the file needs to be copied into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\" )\n\t\t\tself[DriveWizard.PAGE_OLD].hint = msg\n\t\t\tself[DriveWizard.PAGE_OLD].description = ''\n\t\telse:\n\t\t\traise ValueError('Invalid drive-type \"%s\"' % drive_type)\n\n\t\treturn self.type_selected(object)","def create_pressure_vessel_geometry():\r\n\r\n # configure sigmoid function\r\n bounds_upper = [3, 6]\r\n h = 5\r\n w = 6\r\n\r\n sigmoid_function = lambda x: (1 / (1 + np.exp(-1 * h * x + w))) + 1\r\n\r\n sigmoid_function_reverse = lambda x: 1 / (1 + np.exp(h * x - w - 18)) + 1\r\n\r\n funcs_upper = [sigmoid_function, sigmoid_function_reverse]\r\n\r\n bounds_lower = None\r\n funcs_lower = 0\r\n\r\n x_max = 6\r\n x_min = 0\r\n resolution = 10000\r\n\r\n pressure_vessel = Geometry(x_max, x_min, resolution,\r\n bounds_upper, funcs_upper,\r\n bounds_lower, funcs_lower)\r\n\r\n return pressure_vessel","def Gd():\n Pz=[8]\n Pp=[1,1]\n return Pz, Pp","def sel2para(*args):\n return _ida_segment.sel2para(*args)","def choose(self, g, c, p):\n ng = copy.deepcopy(g)\n ng[c[0]][c[1]] = p\n return ng","def build_selection_spec(client_factory, name):\r\n sel_spec = client_factory.create('ns0:SelectionSpec')\r\n sel_spec.name = name\r\n return sel_spec","def pairing_group_create(curve='MNT224'):\n return PairingGroup(curve)","def _select(self):\n sel = []\n\n # choose randomly while favouring fit individuals\n lp = len(self.population) // 2\n for _ in range(lp):\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n while idx1 == idx2:\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n\n p1, p2 = self.population[idx1], self.population[idx2]\n sel.append((p1, p2))\n\n return sel","def pick_grom_group(group, other, selected):\n\treturn Faction(over(group, selected), over(group + other, selected))","def create_point(x_crd, y_crd):\n\n Point = namedtuple(\"Point\", \"x_crd y_crd\")\n return Point(x_crd, y_crd)","def getSelector(self, node):\n self.checkModelOpen()\n calcEngine = CalcEngine.factory(self.client_session)\n return calcEngine.getSelector(node)","def _select_single(self, disc):\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)","def select(self):\n return","def select(self, test):\n survivors = []\n for particle in self.particles:\n # Find the originating particle\n parent = particle\n while parent.origin is not None:\n parent = parent.origin.initial_state[0]\n if test(parent, particle) is True:\n survivors.append(particle)\n return ParticleCollection(survivors)","def select_operator(operators, weights, rnd_state):\n return rnd_state.choice(np.arange(0, len(operators)),\n p=weights / np.sum(weights))","def active_selection():\r\n\r\n om.MGlobal.getActiveSelectionList()","def __call__(self):\n new_node = Node()\n new_node.op = self\n return new_node","def water_selection(self):\n sel_cache = self.pdb_hierarchy.atom_selection_cache()\n sel_str = \"({}) and element O and altloc ' '\".format(\n \" or \".join([ \"resname \" + i for i in WATER_RES_NAMES ]))\n return sel_cache.selection(sel_str).iselection()","def __call__(self):\r\n new_node = Node()\r\n new_node.op = self\r\n return new_node","def selectLinkedElement():\n\n collector = FilteredElementCollector(doc).ToElementIds()\n wrongAngle = []\n for id in collector:\n \n element= doc.GetElement(id)\n\n if element.get_Parameter(BuiltInParameter.FABRICATION_PART_ANGLE) is not None:\n try:\n chord = element.CenterlineLength\n angle = element.get_Parameter(BuiltInParameter.FABRICATION_PART_ANGLE).AsDouble()\n angle = degrees(angle)\n diameter = element.get_Parameter(BuiltInParameter.FABRICATION_PART_DIAMETER_IN).AsDouble()\n radius = ((360/angle)*chord )/(pi*2)\n \n if round(radius,4) == round(diameter,4):\n wrongAngle.append(id)\n\n except Exception as ex:\n print(ex, str(id))\n pass\n\n wrongAngle = List[ElementId](wrongAngle)\n uidoc.Selection.SetElementIds(wrongAngle)","def select(self, *dims):\n return select(self, *dims)","def selection(probs):\n # pick 2 parents out of this distribution\n t = [i for i in range(len(probs))]\n draw = choice(t, 2, p=probs, replace=False)\n return draw","def __make_sel(selection):\n sel = []\n param = []\n for key, value in selection.iteritems(): \n if key == \"fn\":\n if value.find('%') >= 0:\n sel.append(\"irods_filepath like %s\")\n else:\n sel.append(\"irods_filepath = %s\")\n elif key == \"expid\":\n sel.append(\"exper_id = %s\".format(value))\n elif key == 'runnum':\n sel.append(\"runnum = %s\".format(value))\n elif key == 'status' and value:\n sel.append(\"status = %s\")\n else:\n continue\n param.append(value)\n\n q = \"WHERE {}\".format(\" AND \".join(sel)) if sel else \"\"\n return q, param","def createAxisOperationsButtonAndMenu(self):\n button = QtGui.QToolButton()\n menu = QtGui.QMenu(self) \n \n opDefs = ['def default axis points',\n 'sum summation of selected axis points',\n 'avg average of selected axis points',\n 'wgt weighted average of selected axis points',\n 'awt altered weighted average of selected axis points',\n 'gtm geometrical mean of selected axis points',\n 'std standard deviation of selected axis points',]\n \n for op in opDefs:\n action = menu.addAction(op)\n self.connect(action, QtCore.SIGNAL('triggered ()'),\n self.selectAxesOperationEvent)\n\n button.setText(' def ')\n button.setMenu(menu)\n button.setPopupMode(QtGui.QToolButton.InstantPopup)\n\n # Connect Signals\n self.connect(button, QtCore.SIGNAL('clicked(bool)'),\n button.showMenu)\n\n return button","def select_reg(self, r0, r1, add_zeros=False):\r\n # Retrieve database first and last registry entry values\r\n r0_db, r1_db = self.data.index[0], self.data.index[-1]\r\n\r\n # Check invalid input, if r1 > r1_db, add zeros or error.\r\n if r0 < r0_db or r0 >= r1 or r0 > r1_db:\r\n raise IndexError(f'{self} no possible reg selection'\r\n f' for {r0, r1}.')\r\n\r\n elif r1 > r1_db:\r\n if add_zeros:\r\n ind_appen = range(r1_db + 1, r1 + 1)\r\n ad = pd.DataFrame(0, index=ind_appen, columns=self.data.columns)\r\n self.data = self.data.append(ad)\r\n else:\r\n raise IndexError(f'{self} no possible reg selection for '\r\n f'{r0, r1} without adding zeros.')\r\n\r\n # Make the data selection\r\n self.data = self.data.loc[r0: r1 - 1, :]","def pions ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n ##\n if self['NOPIDHADRONS'] :\n from StandardParticles import StdAllNoPIDsPions as inpts\n pioncut = self['PionCut']\n else :\n from StandardParticles import StdAllLooseANNPions as inpts\n pioncut = \"(%s)&(%s)\" % ( self['PionCut'] , self['PionPIDCut'] ) \n ##\n return self.make_selection (\n 'Pion' ,\n FilterDesktop ,\n [ inpts ] ,\n Code = pioncut ,\n )","def include_selection(data, selection):\n\n new_data = list()\n\n for a_data_point in data:\n\n if ('resonance_id' in a_data_point.par and a_data_point.par[\n 'resonance_id'] in selection):\n new_data.append(a_data_point)\n\n return new_data","def __init__(\n self, name: str, values: List[Dict], index: Optional[int] = 0,\n label: Optional[str] = None, help: Optional[str] = None,\n default: Optional[bool] = None, required: Optional[bool] = False,\n group: Optional[str] = None\n ):\n super(Select, self).__init__(\n dtype=PARA_SELECT,\n name=name,\n index=index,\n label=label,\n help=help,\n default=default,\n required=required,\n group=group\n )\n self.values = values","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def __init__(self):\n super().__init__()\n self.p = 0.0\n self.type = 'Geometric'\n self.distType = 'Discrete'\n self.lowerBound = 0.0\n self.upperBound = 1.0\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def selectPointsUnderCursor(self):\n #spw = self.spw\n #sw = spw.windows['Sort']\n #if clear:\n # sw.uslist.clearSelection()\n # sw.nlist.clearSelection()\n x, y = self.cursorPosGL()\n sids = self.pick(x, y, pb=10, multiple=True)\n if sids == None:\n return\n #t0 = time.time()\n #if not sw.panel.maxed_out:\n # spw.SelectSpikes(sids, on=self.selecting)\n #else:\n # # for speed, while the mouse is held down and the sort panel is maxed out,\n # # don't call SelectSpikes, only call it once when the mouse is released\n self.collected_sids.append(sids)\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\n if self.selecting == True:\n sat = 0.2 # desaturate\n else: # self.selecting == False\n sat = 1 # resaturate\n self.color(sids, sat=sat)\n self.updateGL()","def create_menu():\n MenuData = [\n (\"&Draw Variables\",drawable.ask),\n (\"&Show Variables\",printall),\n (\"&Print Variables\",printval),\n (\"&Edit Variable\",edit),\n (\"&Rename Variable\",rename),\n (\"&Forget Variables\",forget),\n (\"---\",None),\n (\"&Create Plane\",\n [(\"Coordinates\", \n [(\"Point and normal\", createPlaneCoordsPointNormal),\n (\"Three points\", createPlaneCoords3Points),\n ]), \n (\"Visually\", \n [(\"Three points\", createPlaneVisual3Points),\n ]),\n ]),\n (\"&Select Plane\",planes.ask),\n (\"&Draw Selection\",planes.draw),\n (\"&Forget Selection\",planes.forget),\n (\"---\",None),\n (\"&Pick Actors\",pick_actors),\n (\"&Pick Elements\",pick_elements),\n (\"&Pick Points\",pick_points),\n (\"&Pick Edges\",pick_edges),\n (\"---\",None),\n ('&Selection',\n [('&Create Report',report_selection),\n ('&Set Property',setprop_selection),\n ('&Grow',grow_selection),\n ('&Partition',partition_selection),\n ('&Get Partition',get_partition),\n ('&Export',export_selection),\n ]),\n (\"---\",None),\n ('&Query',\n [('&Actors',query_actors),\n ('&Elements',query_elements),\n ('&Points',query_points),\n ('&Edges',query_edges),\n ('&Distances',query_distances),\n ]),\n (\"---\",None),\n (\"&Close\",close_menu),\n ]\n return widgets.Menu('Tools',items=MenuData,parent=GD.gui.menu,before='help')","def newConnection(self, btnParent = None):\n selected = cmds.ls(selection = True) #current selection\n\n if btnParent != None: #display button\n parent = btnParent\n selected = []\n else: #make parent current tab\n parent = tab = self.tabwidget.currentWidget()\n\n btnColor = self.color.currentText() #button color\n btnName = self.nameBox.text() #button name\n return self.newDragBtn(btnColor, selected, btnName, parent, self.btnWidth.value(), self.btnHeight.value(), self.tabwidget.currentWidget())","def sir_model():\n ddpp = rmf.DDPP()\n ddpp.add_transition([-1,1,0],lambda x:x[0]+2*x[0]*x[1])\n ddpp.add_transition([0,-1,+1],lambda x:x[1])\n ddpp.add_transition([1,0,-1],lambda x:3*x[2]**3)\n ddpp.set_initial_state([.3,.2,.5]) # We first need to define an initial stater\n return ddpp","def __getSelectionFilter(self):\n \n selectionPairs = []\n selectionPairs.append(('field','field'))\n selectionPairs.append(('spw','spw'))\n selectionPairs.append(('polarization','correlation'))\n selectionPairs.append(('baseline','antenna'))\n selectionPairs.append(('time','timerange'))\n selectionPairs.append(('scan','scan'))\n selectionPairs.append(('uvdist','uvrange'))\n selectionPairs.append(('scanintent','intent'))\n selectionPairs.append(('observation','observation'))\n return self.__generateFilter(selectionPairs)","def sel(\n self,\n **kwargs,\n ) -> \"Dataset\":\n res = [da.sel(**kwargs) for da in self]\n return Dataset(data=res, validate=False)","def PricingStartCurvesVector(builder, numElems):\n return StartCurvesVector(builder, numElems)","def _get_button_region(self):\n # XXXX Only rectangulars for now\n if not self._sensitive:\n return None\n if not self._insidetemporal():\n return None\n rgn = Qd.NewRgn()\n if self._shape == 'rect':\n x0, y0 = self._convert_point(self._coordinates[0:2])\n x1, y1 = self._convert_point(self._coordinates[2:4])\n box = x0, y0, x1, y1\n Qd.RectRgn(rgn, box)\n elif self._shape == 'poly':\n Qd.OpenRgn()\n xl, yl = self._convert_point(self._coordinates[-2:])\n Qd.MoveTo(xl, yl)\n for i in range(0, len(self._coordinates), 2):\n x, y = self._convert_point(self._coordinates[i:i+2])\n Qd.LineTo(x, y)\n Qd.CloseRgn(rgn)\n elif self._shape == 'circle':\n print 'Circle not supported yet'\n elif self._shape == 'ellipse':\n # Note: rx/ry are width/height, not points\n x, y, rx, ry = self._dispobj._window._convert_coordinates(self._coordinates)\n Qd.OpenRgn()\n Qd.FrameOval((x-rx, y-ry, x+rx, y+ry))\n Qd.CloseRgn(rgn)\n else:\n print 'Invalid shape type', self._shape\n return rgn","def selection(self):\r\n if not self._selection:\r\n print(\"not working\")\r\n return None\r\n\r\n year, month = self._date.year, self._date.month\r\n if len(str(month))==1:\r\n month = \"0{}\".format(month)\r\n return (\"{}{}{}\".format(year, month, self._selection[0]), \r\n \"{} / {} / {}\".format(year, month, self._selection[0]))","def range(self, event):\r\n \r\n p = (event.x, self.toCartesian(event.y))\r\n \r\n if self.selectedRegion is None:\r\n self.selectedStart = Region(p[X],p[Y], p[X],p[Y])\r\n self.selectedRegion = self.selectedStart.unionPoint(p)\r\n \r\n self.paint()\r\n \r\n # return (node,sub-tree) where sub-tree is True if draining entire tree\r\n # rooted at node. Draw these as shaded red rectangle to identify whole\r\n # sub-tree is selected.\r\n for pair in self.tree.range(self.selectedRegion):\r\n p = pair[0].point\r\n \r\n if pair[1]:\r\n self.canvas.create_rectangle(pair[0].region.x_min, self.toTk(pair[0].region.y_min), \r\n pair[0].region.x_max, self.toTk(pair[0].region.y_max),\r\n fill='Red', stipple='gray12')\r\n else:\r\n self.canvas.create_rectangle(p[X] - BoxSize, self.toTk(p[Y]) - BoxSize, \r\n p[X] + BoxSize, self.toTk(p[Y]) + BoxSize, fill='Red')\r\n\r\n self.queryRect = self.canvas.create_rectangle(self.selectedRegion.x_min, self.toTk(self.selectedRegion.y_min), \r\n self.selectedRegion.x_max, self.toTk(self.selectedRegion.y_max), \r\n outline='Red', dash=(2, 4))","def ipset_one_x_new():\n x = np.linspace(-3, 3, 11)\n return IPSet(x=x, y=x ** 2, x_new=1)"],"string":"[\n \"def make_selection ( self ,\\n tag , \\n algotype ,\\n inputs , \\n *args ,\\n **kwargs ) :\\n sel_tag = '%s_Selection' % tag\\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\\n #\\n ## check existing selection\\n #\\n sel = self._selection ( sel_tag )\\n if sel : return sel \\n\\n #\\n ## adjust a bit the arguments\\n if not kwargs.has_key('Preambulo') :\\n kwargs ['Preambulo' ] = self['Preambulo']\\n\\n if not kwargs.has_key( 'ParticleCombiners' ) :\\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \\n \\n # \\n ## use \\\"simple-selection\\\"\\n #\\n from PhysSelPython.Wrappers import SimpleSelection\\n sel = SimpleSelection (\\n sel_name ,\\n algotype ,\\n inputs , \\n *args ,\\n **kwargs )\\n # \\n return self._add_selection( sel_tag , sel )\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_point()\\n return cls.from_guid(guid)\",\n \"def makeDstar2D0Pi( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n daugCuts = \\\"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\\\" % locals()['config']\\n combCuts = \\\"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\\\" % locals()['config']\\n dstarCuts = \\\"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\\\" \\\\\\n \\\"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\\\" % locals()['config']\\n\\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"pi+\\\" : daugCuts }\\n , CombinationCut = combCuts\\n , MotherCut = dstarCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dstar,\\n RequiredSelections = inputSel\\n )\",\n \"def create(cls, selection):\\n\\t\\t\\n\\t\\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })\",\n \"def get_selection():\\n\\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\\n sel_len = len(selected)\\n result = SelectionContainer()\\n\\n for _x in range(0, sel_len):\\n\\n shape_type = selected[_x].ShapeType\\n\\n if shape_type == 'Vertex':\\n result.vertices.append(selected[_x])\\n\\n elif shape_type == 'Edge':\\n\\n if 'Line' in str(selected[_x].Curve):\\n result.lines.append(selected[_x])\\n else:\\n result.curves.append(selected[_x])\",\n \"def curve_through_selection(*args):\\n sel = cmds.ls(sl=True, fl=True)\\n if not sel or len(sel)==1:\\n cmds.warning(\\\"You need to select multiple things to create curve through!\\\")\\n return()\\n\\n pList = []\\n crvType = cmds.radioButtonGrp(widgets[\\\"crvSelRBG\\\"], q=True, sl=True)\\n\\n for obj in sel:\\n if cmds.objectType(obj) in [\\\"transform\\\"]:\\n pos = cmds.xform(obj, q=True, ws=True, rp=True)\\n pList.append(pos)\\n elif obj in cmds.filterExpand(sm=[28, 30, 31, 32, 34, 46]):\\n pos = cmds.pointPosition(obj)\\n pList.append(pos)\\n\\n #add points if only 2 (cv, ep) or 3 (cv) are given, and create the curve\\n if crvType == 1:\\n if len(pList) == 2:\\n f = [float(sum(x)/2) for x in zip(*pList)]\\n pList.insert(1, f)\\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\\n pList.insert(1, newPt1)\\n pList.insert(3, newPt2)\\n if len(pList) == 3:\\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\\n pList.insert(1, newPt1)\\n pList.insert(3, newPt2)\\n crv = cmds.curve(d=3, p=pList, name=\\\"newCurve\\\")\\n\\n if crvType == 2:\\n if len(pList) == 2:\\n f = [float(sum(x)/2) for x in zip(*pList)]\\n pList.insert(1, f)\\n crv = cmds.curve(d=3, ep=pList, name=\\\"newCurve\\\")\\n\\n return(crv)\",\n \"def selectAdd(op):\\n doc = op.GetDocument()\\n doc.SetActiveObject(op, c4d.SELECTION_ADD)\",\n \"def get_gold_selection(self, pointer):\\n raise NotImplementedError\",\n \"def makePseudoPsi( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n _daugCuts = \\\"(PT> %(D0PtLoose)s*MeV)\\\" % locals()['config']\\n _combCuts = \\\"(APT> %(D0PtLoose)s*MeV)\\\" % locals()['config']\\n\\n _Psi = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"D0\\\": _daugCuts }\\n , CombinationCut = _combCuts\\n , MotherCut = \\\"(VFASPF(VCHI2PDOF) < 10000)\\\"\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Psi,\\n RequiredSelections = inputSel\\n )\",\n \"def selectVertex(self, addToSelection: bool) -> None:\\n ...\",\n \"def createSelector(self,type='select',speed=2.0):\\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector.hide()\\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def createSelector2(self,type='select',speed=2.0):\\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector2.hide()\\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def makeSelection(self, selection=\\\"\\\"):\\n\\n\\t\\tif selection == \\\"\\\":\\n\\t\\t\\tprint \\\"usage: makeSelection(selection)\\\"\\n\\n\\t\\tsel_string = self.parseMacros(selection)\\n\\n\\t\\t# --- split by \\\";\\\" --- #\\n\\t\\ttmp = []\\n\\t\\tcols = []\\n\\t\\tcols = sel_string.split(\\\";\\\")\\n\\t\\tfor col in cols:\\n\\t\\t\\tinverse = False\\n\\t\\t\\tif col == \\\"\\\":\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\ttmp = string.split(col, \\\"=\\\")\\n\\t\\t\\tif \\\"!\\\" in tmp[0]:\\n\\t\\t\\t\\tinverse = True\\n\\n\\t\\t\\tif \\\"resi\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseResI(tmp[1])\\n\\t\\t\\t\\tself.invresi = inverse\\n\\t\\t\\telif \\\"resn\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseResN(tmp[1])\\n\\t\\t\\t\\tself.invresn = inverse\\n\\t\\t\\telif \\\"name\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(tmp[1])\\n\\t\\t\\t\\tself.invatom = inverse\\n\\t\\t\\telif \\\"element\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseElement(tmp[1])\\n\\t\\t\\t\\tself.invelement = inverse\\t\\n\\t\\t\\telif \\\"chain\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseChain(tmp[1])\\n\\t\\t\\t\\tself.invchain = inverse\\n\\t\\t\\telif \\\"type\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseType(tmp[1])\\n\\t\\t\\t\\tself.invtype = inverse\\n\\t\\t\\telif \\\"cat\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseCat(tmp[1])\\n\\t\\t\\t\\tself.invcat = inverse\\n\\t\\t\\telif \\\"atomid\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtomid(tmp[1])\\n\\t\\t\\t\\tself.invatomid = inverse\\n\\t\\t\\telif \\\"BB\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O \\\")\\n\\t\\t\\t\\tself.invatom = False\\n\\t\\t\\telif \\\"CEN\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O , CB \\\")\\n\\t\\t\\t\\tself.invatom = False\\n\\t\\t\\telif \\\"SC\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseAtom(\\\" N , CA , C , O \\\")\\n\\t\\t\\t\\tself.invatom = True\\n\\t\\t\\telif \\\"HET\\\" in tmp[0]:\\n\\t\\t\\t\\tself.parseType(\\\"HETATM\\\")\\n\\t\\t\\t\\tself.invtype = inverse\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint \\\"unrecognized selector: \\\",tmp[0]\\n\\t\\t\\t\\tsys.exit()\",\n \"def 选择项目(self, n): # real signature unknown; restored from __doc__\\n return self.Select(n)\",\n \"def _add_selection ( self , nick , sel ) :\\n if not self.__selections_.has_key ( self.name() ) :\\n self.__selections_[ self.name() ] = {} \\n \\n if self.__selections_[ self.name()].has_key( nick ) :\\n raise AttributeError , \\\"Selection '%s'already exists \\\" % nick\\n \\n self.__selections_[ self.name() ][ nick ] = sel\\n \\n return sel\",\n \"def selectAdd(node):\\n node['selected'].setValue(True)\",\n \"def from_selection(\\n class_,\\n selection,\\n item_class=None,\\n ):\\n import abjad\\n pitch_segment = abjad.PitchSegment.from_selection(selection)\\n return class_(\\n pitch_segment,\\n item_class=item_class,\\n )\",\n \"def makeDefault(name,inputSel) :\\n from Configurables import OfflineVertexFitter\\n Detached4mu = CombineParticles(\\\"Combine\\\"+name)\\n Detached4mu.DecayDescriptor = \\\"B_s0 -> mu+ mu- mu+ mu-\\\"\\n # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:\\n Detached4mu.addTool( OfflineVertexFitter )\\n Detached4mu.ParticleCombiners.update( { \\\"\\\" : \\\"OfflineVertexFitter\\\"} )\\n Detached4mu.OfflineVertexFitter.useResonanceVertex = False\\n Detached4mu.ReFitPVs = True\\n Detached4mu.DaughtersCuts = { \\\"mu+\\\" : \\\"(TRCHI2DOF < 2.5 ) \\\"\\\\\\n \\\" & (MIPCHI2DV(PRIMARY)> 9.)\\\"}\\n \\n Detached4mu.CombinationCut = \\\"(ADAMASS('B_s0')<1000*MeV) \\\"\\\\\\n \\\"& (AMAXDOCA('')<0.3*mm)\\\"\\n Detached4mu.MotherCut = \\\"(VFASPF(VCHI2/VDOF)<9) \\\"\\\\\\n \\\"& (BPVDIRA > 0) \\\"\\\\\\n \\\"& (BPVVDCHI2>100)\\\"\\\\\\n \\\" & (M>4366.3) & (M<6366.3)\\\"\\\\\\n \\\"& (BPVIPCHI2()< 25) \\\"\\n \\n\\n return Selection (name,\\n Algorithm = Detached4mu,\\n RequiredSelections = inputSel)\",\n \"def instantiateNewCmd(self):\\n return QadGRIPSTRETCHCommandClass(self.plugIn)\",\n \"def add_new_to_sel(self):\\n self.parent().do_new(keep_sel=True)\",\n \"def make_odorant_selector(name):\\n return dcc.Input(\\n id=\\\"cid_%s\\\" % name,\\n placeholder=\\\"Enter a PubChem ID number...\\\",\\n type=\\\"number\\\",\\n value=None,\\n )\",\n \"def __init__(self, parent):\\n # parent is the main frame of PyCorrFit\\n self.parent = parent\\n ## MYID\\n # This ID is given by the parent for an instance of this class\\n self.MyID = None\\n ## Wrapping\\n curvedict, labels = self.GetCurvedict()\\n self.labels = labels\\n self.Selector = UserSelectCurves(parent, curvedict,\\n wrapper=self, labels=labels)\\n # This is necessary for parent to deselect and select the tool\\n # in the tools menu.\\n self.Bind = self.Selector.Bind\\n if self.parent.notebook.GetPageCount() == 0:\\n self.Selector.sp.Disable()\",\n \"def addSelectedToCanvas(self):\\n\\n selected = self.moduleList.currentItem()\\n module = selected.data(QtCore.Qt.UserRole)[0]\\n\\n index = self.pickerUI.characterTabs.currentIndex()\\n widget = self.pickerUI.characterTabs.widget(index)\\n characterNode = widget.property(\\\"charNode\\\")\\n\\n # get inst\\n modType = cmds.getAttr(module + \\\".moduleType\\\")\\n modName = cmds.getAttr(module + \\\".moduleName\\\")\\n mod = __import__(\\\"RigModules.\\\" + modType, {}, {}, [modType])\\n reload(mod)\\n\\n # get the class name from that module file (returns RigModules.ART_Root.ART_Root for example)\\n moduleClass = getattr(mod, mod.className)\\n\\n # find the instance of that module\\n moduleInst = moduleClass(self, modName)\\n self.modules.append(moduleInst)\\n\\n scene = self.getCurrentCanvasTab()\\n\\n # find out if charNode has a namespace\\n if cmds.objExists(characterNode + \\\".namespace\\\"):\\n namespace = cmds.getAttr(characterNode + \\\".namespace\\\") + \\\":\\\"\\n else:\\n namespace = \\\"\\\"\\n\\n # pass in the network node and the namespace\\n picker = moduleInst.pickerUI(scene.sceneRect().center(), self.pickerUI, module, namespace)\\n scene.addItem(picker[0])\\n self.pickerUI.selectionScriptJobs.append(picker[2])\\n\\n # =======================================================================\\n # #mirror the module's pickerBorderItem if needed\\n # =======================================================================\\n if picker[1] == True:\\n picker[0].setTransformOriginPoint(picker[0].boundingRect().center())\\n picker[0].setTransform(QtGui.QTransform(-1.0, 0.0, 0.0, 1.0, picker[0].boundingRect().width() * 2, 0.0))\\n\\n children = picker[0].childItems()\\n if children is not None:\\n self.mirrorChildren(children)\\n\\n row = self.moduleList.row(selected)\\n self.moduleList.takeItem(row)\",\n \"def select(*args, add: bool=True, addFirst: bool=True, all: bool=True, allDagObjects: bool=True,\\n allDependencyNodes: bool=True, clear: bool=True, containerCentric: bool=True,\\n deselect: bool=True, hierarchy: bool=True, noExpand: bool=True, replace: bool=True,\\n symmetry: bool=True, symmetrySide: int=0, toggle: bool=True, visible: bool=True,\\n **kwargs)->None:\\n pass\",\n \"def select(self):\\n\\n return self.p[0], self.p[1]\",\n \"def db(r):\\n ey = gQ(r)\\n gR = b.tcl(\\n 'global no_gizmo; set no_gizmo 1; in %s {%s -New} ; return [value [stack 0].name]' % (ey.fullName(), r.Class()))\\n group = b.toNode('.'.join((ey.fullName(), gR)))\\n group.setSelected(False)\\n if ew(r):\\n for node, gS in ew(r).iteritems():\\n for c in gS:\\n node.setInput(c, group)\\n\\n for c in range(r.inputs()):\\n group.setInput(c, r.input(c))\\n\\n group.setXYpos(r.xpos(), r.ypos())\\n group.readKnobs(r.writeKnobs(b.TO_SCRIPT))\\n b.delete(r)\\n return group\",\n \"def pass_selection_dR(self, dR):\\n dR_max = self.cut_dict[self.sample_name][\\\"dR_cut\\\"]\\n return self.pass_selection_val(val=dR, val_max=dR_max)\",\n \"def generate_kdtree(self):\\n if self.method==2:\\n coordinates = self.unassigned_data[0:3,:]\\n else:\\n coordinates = self.unassigned_data[0:2,:]\\n tree = cKDTree(coordinates.T)\\n\\n return tree\",\n \"def make_selection(self, num):\\n other_doors = None\\n if num is 1:\\n other_doors = [str(2), str(3)]\\n elif num is 2:\\n other_doors = [str(1), str(3)]\\n elif num is 3:\\n other_doors = [str(1), str(2)]\\n\\n reveal = str(random.choice(other_doors))\\n other_doors.remove(reveal)\\n third_door = random.choice(other_doors)\\n other_doors.remove(third_door)\\n\\n main_door = getattr(self, 'door' + str(num) + '_counter')\\n door_second = getattr(self, 'door' + reveal + '_counter')\\n door_third = getattr(self, 'door' + third_door + '_counter')\\n main_door_reveal = getattr(self, 'door'+str(num)+'_reveal')\\n\\n if (main_door is 0 and door_second is 0\\n and door_third is 0):\\n self.ids['door'+reveal].source = \\\\\\n getattr(self, 'door'+reveal+'_reveal')\\n self.ids['button'+reveal].disabled = True\\n inc = getattr(self, 'door' + str(num) + '_counter')\\n setattr(self, 'door' + str(num) + '_counter', inc + 1)\\n elif main_door is 1 and door_second is 0 and door_third is 0:\\n for i in range(1, 4, 1):\\n self.ids['door' + str(i)].source = \\\\\\n getattr(self, 'door' + str(i) + '_reveal')\\n self.ids['button'+str(i)].disabled = True\\n if main_door_reveal in ['door-money.png']:\\n self.win_popup()\\n else:\\n self.lose_popup()\\n elif main_door is 0 and (door_second is 1 or door_third is 1):\\n for i in range(1, 4, 1):\\n self.ids['door' + str(i)].source = \\\\\\n getattr(self, 'door' + str(i) + '_reveal')\\n self.ids['button'+str(i)].disabled = True\\n if main_door_reveal in ['door-money.png']:\\n self.win_popup()\\n else:\\n self.lose_popup()\",\n \"def get_selection(self, selection_name, format=None):\",\n \"def __call__(self) -> abjad.Selection:\\n if (self._repetition_chance == 0.0\\n or random.random() > self._repetition_chance):\\n if not self._is_first_window or self._process_on_first_call:\\n if self._mode == 'out':\\n self._remove_element()\\n else:\\n self._add_element()\\n elif not self._include_empty_measures and self._mode == 'in':\\n self._add_element()\\n self._mask_to_selection()\\n return self.current_window\",\n \"def polySelect(*args, add: bool=True, addFirst: bool=True, asSelectString: bool=True, deselect:\\n bool=True, edgeBorder: Union[int, List[int], bool]=0, edgeBorderPath:\\n Union[List[int, int], List[List[int, int]], bool]=None, edgeBorderPattern:\\n Union[List[int, int], List[List[int, int]], bool]=None, edgeLoop: Union[int,\\n List[int], bool]=0, edgeLoopOrBorder: Union[int, List[int], bool]=0,\\n edgeLoopOrBorderPattern: Union[List[int, int], List[List[int, int]], bool]=None,\\n edgeLoopPath: Union[List[int, int], List[List[int, int]], bool]=None,\\n edgeLoopPattern: Union[List[int, int], List[List[int, int]], bool]=None,\\n edgeRing: Union[int, List[int], bool]=0, edgeRingPath: Union[List[int, int],\\n List[List[int, int]], bool]=None, edgeRingPattern: Union[List[int, int],\\n List[List[int, int]], bool]=None, edgeUVLoopOrBorder: Union[int, List[int],\\n bool]=0, everyN: int=0, extendToShell: Union[int, List[int], bool]=0,\\n noSelection: bool=True, replace: bool=True, shortestEdgePath: Union[List[int,\\n int], List[List[int, int]], bool]=None, shortestEdgePathUV: Union[List[int, int],\\n List[List[int, int]], bool]=None, shortestFacePath: Union[List[int, int],\\n List[List[int, int]], bool]=None, toggle: bool=True, q=True, query=True,\\n **kwargs)->Union[List[int], Any]:\\n pass\",\n \"def selection(self):\\n # create an empty priority queue for the new generation\\n newGeneration = PriorityQueue()\\n # pick top X of the population to survive\\n for c in range(0, self.generation.qsize() / SELECTION_FRACTION):\\n # get a chromosome\\n chromosome = self.generation.get()\\n # put the chromosomes in the new generation\\n newGeneration.put(chromosome)\\n # keep the new generation\\n self.generation = newGeneration\",\n \"def new_piece(self):\\n piece_type = pieces.PieceSelector.select_random_piece()\\n return piece_type(game_config.NEXT_PIECE_POSX, game_config.NEXT_PIECE_POSY)\",\n \"def project(record, selected, pkey_name) -> StateDictInterface:\\n if selected:\\n keys = set(selected.keys()) | {pkey_name}\\n return record.projection(keys)\\n else:\\n return record\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_mesh()\\n return cls.from_guid(guid)\",\n \"def select(self):\\n\\t\\tbest_num_components = self.n_constant\\n\\t\\treturn self.base_model(best_num_components)\",\n \"def select(self):\\n pass\",\n \"def select(self):\\n pass\",\n \"def get_next_gp(self):\\n next_gp = self.gpf_core.get_next_gp()[2]\\n next_gp.build_posterior()\\n return DragonflyGP(next_gp, self.options)\",\n \"def newDragBtn(self, color, selected, name, parent, width, height, tabIndex):\\n btn = drag.DragButton(color, selected, self, name ) #create new draggable button\\n btn.setParent(parent)\\n btn.resize(width, height)\\n btn.show() #show button\\n logger.info(\\\"new button: %s\\\" % name)\\n\\n #add to objects dictionary\\n if selected != None:\\n for i in selected:\\n if(i in self.objects[tabIndex]):\\n self.objects[tabIndex][str(i)].append(btn) #add to array of buttons\\n else:\\n self.objects[tabIndex][str(i)]=[btn] #create array of buttons\\n logger.debug(self.objects)\\n else:\\n logger.error(\\\"nothing is being connected to button\\\")\\n\\n return btn\",\n \"def select(self, new_pop, new_vals):\\n raise NotImplemented(\\n \\\"Method `EvolutionaryAlgorithm.select` should be implemented in subclasses!\\\")\",\n \"def instantiateNewCmd(self):\\n return QadSTRETCHCommandClass(self.plugIn)\",\n \"def create_gui(self):\\n\\n selectors_widgets = list()\\n\\n for n in range(4):\\n\\n selectors_widgets.append(wd.Dropdown(\\n options={'': 0, 'Orange': 1, 'Red': 2, 'Blue': 3, 'Green': 4},\\n value=0,\\n disabled=False,\\n layout={'width': '148px'}\\n ))\\n\\n self.confirm_button.on_click(\\n self.create_combination_and_rate_function())\\n self.user_interact.children = [self.selectors, self.confirm_button]\\n\\n self.selectors.children = selectors_widgets\",\n \"def to_pda(self) -> \\\"pda.PDA\\\":\\n state = pda.State(\\\"q\\\")\\n pda_object_creator = PDAObjectCreator(self._terminals, self._variables)\\n input_symbols = {pda_object_creator.get_symbol_from(x)\\n for x in self._terminals}\\n stack_alphabet = {pda_object_creator.get_stack_symbol_from(x)\\n for x in self._terminals.union(self._variables)}\\n start_stack_symbol = pda_object_creator.get_stack_symbol_from(\\n self._start_symbol)\\n new_pda = pda.PDA(states={state},\\n input_symbols=input_symbols,\\n stack_alphabet=stack_alphabet,\\n start_state=state,\\n start_stack_symbol=start_stack_symbol)\\n for production in self._productions:\\n new_pda.add_transition(state, pda.Epsilon(),\\n pda_object_creator.get_stack_symbol_from(\\n production.head),\\n state,\\n [pda_object_creator.get_stack_symbol_from(x)\\n for x in production.body])\\n for terminal in self._terminals:\\n new_pda.add_transition(state,\\n pda_object_creator.get_symbol_from(\\n terminal),\\n pda_object_creator.get_stack_symbol_from(\\n terminal),\\n state, [])\\n return new_pda\",\n \"def _create_features_dropdown(self, name=_features_dropdown):\\n fts = sorted(self.features)\\n d = Select(options=fts, css_classes=[self._features_dropdown], name=name)\\n return d\",\n \"def _getAsSelection(self):\\n return self._asSelection\",\n \"def softSelect(*args, compressUndo: Union[int, bool]=0, enableFalseColor: Union[int, bool]=0,\\n softSelectColorCurve: Union[AnyStr, bool]=\\\"\\\", softSelectCurve: Union[AnyStr,\\n bool]=\\\"\\\", softSelectDistance: Union[float, bool]=0.0, softSelectEnabled:\\n Union[int, bool]=0, softSelectFalloff: Union[int, bool]=0, softSelectReset:\\n bool=True, softSelectUVDistance: Union[float, bool]=0.0, q=True, query=True,\\n e=True, edit=True, **kwargs)->Union[None, Any]:\\n pass\",\n \"def select(self):\\r\\n pass\",\n \"def createGraphPoint(self, cls, newId):\\n def getUniqueId(container, base):\\n ids = set(container.objectIds())\\n new = base\\n i = 2\\n while new in ids:\\n new = '%s%s' % (base, i)\\n i += 1\\n return new\\n newId = getUniqueId(self.graphPoints, newId)\\n gp = cls(newId)\\n # Set sequence\\n if gp.isThreshold:\\n gp.sequence = -1\\n else:\\n gp.sequence = len(self.graphPoints())\\n # Set legend for graph points on multigraph reports\\n if self.report() and hasattr(gp, 'legend'):\\n # For MultiGraphReports we use a fancier legend\\n # to differentiate when you have multiple devices/graphpoints\\n # on a single graph\\n gp.legend = gp.DEFAULT_MULTIGRAPH_LEGEND\\n self.graphPoints._setObject(gp.id, gp)\\n gp = self.graphPoints._getOb(gp.id)\\n if gp.sequence == -1:\\n self.manage_resequenceGraphPoints()\\n return gp\",\n \"def __init__(self, pvID, pvP, pvQ, pvDescriptor):\\n\\n # TODO: implement this\",\n \"def pool_selected( self, object ):\\n\\t\\tud.debug( ud.ADMIN, ud.INFO, 'UVMM.DW.ps(node_uri=%s)' % self.node_uri)\\n\\t\\tpool_name = object.options.get('pool-name')\\n\\t\\tif not pool_name:\\n\\t\\t\\tpool_name = object.options['pool-name'] = 'default'\\n\\t\\tdrive_type = object.options['drive-type']\\n\\t\\ttry:\\n\\t\\t\\tif drive_type == 'cdrom':\\n\\t\\t\\t\\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'cdrom')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'disk' )\\n\\t\\texcept uvmmd.UvmmError, e:\\n\\t\\t\\tvols = ()\\n\\t\\tud.debug(ud.ADMIN, ud.INFO, 'UVMM.DW.ps: volumes=%s' % map(str, vols))\\n\\t\\tchoices = []\\n\\t\\tfor vol in vols:\\n\\t\\t\\tbasename = os.path.basename( vol.source )\\n\\t\\t\\tif '.' in basename:\\n\\t\\t\\t\\tsuffix = basename[ basename.rfind( '.' ) + 1 : ]\\n\\t\\t\\t\\tif suffix in ( 'xml', 'snapshot' ):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\tchoices.append( basename )\\n\\t\\tchoices.sort()\\n\\t\\tself.image_syntax.update_choices( choices )\\n\\n\\t\\t# recreate pool button\\n\\t\\tbtn = self._create_pool_select_button( object.options )\\n\\t\\tself[DriveWizard.PAGE_OLD].options[0] = btn\\n\\t\\tself[DriveWizard.PAGE_NEW].options[0] = btn\\n\\t\\t# recreate driver-type button\\n\\t\\titems = [self[DriveWizard.PAGE_NEW].options[2].id(), self[DriveWizard.PAGE_NEW].options[3].id()]\\n\\t\\tbtn = self._create_type_select_button(object.options, items)\\n\\t\\tself[DriveWizard.PAGE_NEW].options[1] = btn\\n\\n\\t\\tif drive_type == 'disk':\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].hint = None\\n\\t\\telif drive_type in ( 'cdrom', 'floppy' ):\\n\\t\\t\\tif self.image_syntax._choices:\\n\\t\\t\\t\\tmsg = _( \\\"If the required image is not found it might be added by copying the file into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\\\" )\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmsg = _( \\\"The list of available images is empty! To add an image the file needs to be copied into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\\\" )\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].hint = msg\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].description = ''\\n\\t\\telse:\\n\\t\\t\\traise ValueError('Invalid drive-type \\\"%s\\\"' % drive_type)\\n\\n\\t\\treturn self.type_selected(object)\",\n \"def create_pressure_vessel_geometry():\\r\\n\\r\\n # configure sigmoid function\\r\\n bounds_upper = [3, 6]\\r\\n h = 5\\r\\n w = 6\\r\\n\\r\\n sigmoid_function = lambda x: (1 / (1 + np.exp(-1 * h * x + w))) + 1\\r\\n\\r\\n sigmoid_function_reverse = lambda x: 1 / (1 + np.exp(h * x - w - 18)) + 1\\r\\n\\r\\n funcs_upper = [sigmoid_function, sigmoid_function_reverse]\\r\\n\\r\\n bounds_lower = None\\r\\n funcs_lower = 0\\r\\n\\r\\n x_max = 6\\r\\n x_min = 0\\r\\n resolution = 10000\\r\\n\\r\\n pressure_vessel = Geometry(x_max, x_min, resolution,\\r\\n bounds_upper, funcs_upper,\\r\\n bounds_lower, funcs_lower)\\r\\n\\r\\n return pressure_vessel\",\n \"def Gd():\\n Pz=[8]\\n Pp=[1,1]\\n return Pz, Pp\",\n \"def sel2para(*args):\\n return _ida_segment.sel2para(*args)\",\n \"def choose(self, g, c, p):\\n ng = copy.deepcopy(g)\\n ng[c[0]][c[1]] = p\\n return ng\",\n \"def build_selection_spec(client_factory, name):\\r\\n sel_spec = client_factory.create('ns0:SelectionSpec')\\r\\n sel_spec.name = name\\r\\n return sel_spec\",\n \"def pairing_group_create(curve='MNT224'):\\n return PairingGroup(curve)\",\n \"def _select(self):\\n sel = []\\n\\n # choose randomly while favouring fit individuals\\n lp = len(self.population) // 2\\n for _ in range(lp):\\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n while idx1 == idx2:\\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n\\n p1, p2 = self.population[idx1], self.population[idx2]\\n sel.append((p1, p2))\\n\\n return sel\",\n \"def pick_grom_group(group, other, selected):\\n\\treturn Faction(over(group, selected), over(group + other, selected))\",\n \"def create_point(x_crd, y_crd):\\n\\n Point = namedtuple(\\\"Point\\\", \\\"x_crd y_crd\\\")\\n return Point(x_crd, y_crd)\",\n \"def getSelector(self, node):\\n self.checkModelOpen()\\n calcEngine = CalcEngine.factory(self.client_session)\\n return calcEngine.getSelector(node)\",\n \"def _select_single(self, disc):\\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)\",\n \"def select(self):\\n return\",\n \"def select(self, test):\\n survivors = []\\n for particle in self.particles:\\n # Find the originating particle\\n parent = particle\\n while parent.origin is not None:\\n parent = parent.origin.initial_state[0]\\n if test(parent, particle) is True:\\n survivors.append(particle)\\n return ParticleCollection(survivors)\",\n \"def select_operator(operators, weights, rnd_state):\\n return rnd_state.choice(np.arange(0, len(operators)),\\n p=weights / np.sum(weights))\",\n \"def active_selection():\\r\\n\\r\\n om.MGlobal.getActiveSelectionList()\",\n \"def __call__(self):\\n new_node = Node()\\n new_node.op = self\\n return new_node\",\n \"def water_selection(self):\\n sel_cache = self.pdb_hierarchy.atom_selection_cache()\\n sel_str = \\\"({}) and element O and altloc ' '\\\".format(\\n \\\" or \\\".join([ \\\"resname \\\" + i for i in WATER_RES_NAMES ]))\\n return sel_cache.selection(sel_str).iselection()\",\n \"def __call__(self):\\r\\n new_node = Node()\\r\\n new_node.op = self\\r\\n return new_node\",\n \"def selectLinkedElement():\\n\\n collector = FilteredElementCollector(doc).ToElementIds()\\n wrongAngle = []\\n for id in collector:\\n \\n element= doc.GetElement(id)\\n\\n if element.get_Parameter(BuiltInParameter.FABRICATION_PART_ANGLE) is not None:\\n try:\\n chord = element.CenterlineLength\\n angle = element.get_Parameter(BuiltInParameter.FABRICATION_PART_ANGLE).AsDouble()\\n angle = degrees(angle)\\n diameter = element.get_Parameter(BuiltInParameter.FABRICATION_PART_DIAMETER_IN).AsDouble()\\n radius = ((360/angle)*chord )/(pi*2)\\n \\n if round(radius,4) == round(diameter,4):\\n wrongAngle.append(id)\\n\\n except Exception as ex:\\n print(ex, str(id))\\n pass\\n\\n wrongAngle = List[ElementId](wrongAngle)\\n uidoc.Selection.SetElementIds(wrongAngle)\",\n \"def select(self, *dims):\\n return select(self, *dims)\",\n \"def selection(probs):\\n # pick 2 parents out of this distribution\\n t = [i for i in range(len(probs))]\\n draw = choice(t, 2, p=probs, replace=False)\\n return draw\",\n \"def __make_sel(selection):\\n sel = []\\n param = []\\n for key, value in selection.iteritems(): \\n if key == \\\"fn\\\":\\n if value.find('%') >= 0:\\n sel.append(\\\"irods_filepath like %s\\\")\\n else:\\n sel.append(\\\"irods_filepath = %s\\\")\\n elif key == \\\"expid\\\":\\n sel.append(\\\"exper_id = %s\\\".format(value))\\n elif key == 'runnum':\\n sel.append(\\\"runnum = %s\\\".format(value))\\n elif key == 'status' and value:\\n sel.append(\\\"status = %s\\\")\\n else:\\n continue\\n param.append(value)\\n\\n q = \\\"WHERE {}\\\".format(\\\" AND \\\".join(sel)) if sel else \\\"\\\"\\n return q, param\",\n \"def createAxisOperationsButtonAndMenu(self):\\n button = QtGui.QToolButton()\\n menu = QtGui.QMenu(self) \\n \\n opDefs = ['def default axis points',\\n 'sum summation of selected axis points',\\n 'avg average of selected axis points',\\n 'wgt weighted average of selected axis points',\\n 'awt altered weighted average of selected axis points',\\n 'gtm geometrical mean of selected axis points',\\n 'std standard deviation of selected axis points',]\\n \\n for op in opDefs:\\n action = menu.addAction(op)\\n self.connect(action, QtCore.SIGNAL('triggered ()'),\\n self.selectAxesOperationEvent)\\n\\n button.setText(' def ')\\n button.setMenu(menu)\\n button.setPopupMode(QtGui.QToolButton.InstantPopup)\\n\\n # Connect Signals\\n self.connect(button, QtCore.SIGNAL('clicked(bool)'),\\n button.showMenu)\\n\\n return button\",\n \"def select_reg(self, r0, r1, add_zeros=False):\\r\\n # Retrieve database first and last registry entry values\\r\\n r0_db, r1_db = self.data.index[0], self.data.index[-1]\\r\\n\\r\\n # Check invalid input, if r1 > r1_db, add zeros or error.\\r\\n if r0 < r0_db or r0 >= r1 or r0 > r1_db:\\r\\n raise IndexError(f'{self} no possible reg selection'\\r\\n f' for {r0, r1}.')\\r\\n\\r\\n elif r1 > r1_db:\\r\\n if add_zeros:\\r\\n ind_appen = range(r1_db + 1, r1 + 1)\\r\\n ad = pd.DataFrame(0, index=ind_appen, columns=self.data.columns)\\r\\n self.data = self.data.append(ad)\\r\\n else:\\r\\n raise IndexError(f'{self} no possible reg selection for '\\r\\n f'{r0, r1} without adding zeros.')\\r\\n\\r\\n # Make the data selection\\r\\n self.data = self.data.loc[r0: r1 - 1, :]\",\n \"def pions ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n ##\\n if self['NOPIDHADRONS'] :\\n from StandardParticles import StdAllNoPIDsPions as inpts\\n pioncut = self['PionCut']\\n else :\\n from StandardParticles import StdAllLooseANNPions as inpts\\n pioncut = \\\"(%s)&(%s)\\\" % ( self['PionCut'] , self['PionPIDCut'] ) \\n ##\\n return self.make_selection (\\n 'Pion' ,\\n FilterDesktop ,\\n [ inpts ] ,\\n Code = pioncut ,\\n )\",\n \"def include_selection(data, selection):\\n\\n new_data = list()\\n\\n for a_data_point in data:\\n\\n if ('resonance_id' in a_data_point.par and a_data_point.par[\\n 'resonance_id'] in selection):\\n new_data.append(a_data_point)\\n\\n return new_data\",\n \"def __init__(\\n self, name: str, values: List[Dict], index: Optional[int] = 0,\\n label: Optional[str] = None, help: Optional[str] = None,\\n default: Optional[bool] = None, required: Optional[bool] = False,\\n group: Optional[str] = None\\n ):\\n super(Select, self).__init__(\\n dtype=PARA_SELECT,\\n name=name,\\n index=index,\\n label=label,\\n help=help,\\n default=default,\\n required=required,\\n group=group\\n )\\n self.values = values\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def __init__(self):\\n super().__init__()\\n self.p = 0.0\\n self.type = 'Geometric'\\n self.distType = 'Discrete'\\n self.lowerBound = 0.0\\n self.upperBound = 1.0\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def selectPointsUnderCursor(self):\\n #spw = self.spw\\n #sw = spw.windows['Sort']\\n #if clear:\\n # sw.uslist.clearSelection()\\n # sw.nlist.clearSelection()\\n x, y = self.cursorPosGL()\\n sids = self.pick(x, y, pb=10, multiple=True)\\n if sids == None:\\n return\\n #t0 = time.time()\\n #if not sw.panel.maxed_out:\\n # spw.SelectSpikes(sids, on=self.selecting)\\n #else:\\n # # for speed, while the mouse is held down and the sort panel is maxed out,\\n # # don't call SelectSpikes, only call it once when the mouse is released\\n self.collected_sids.append(sids)\\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\\n if self.selecting == True:\\n sat = 0.2 # desaturate\\n else: # self.selecting == False\\n sat = 1 # resaturate\\n self.color(sids, sat=sat)\\n self.updateGL()\",\n \"def create_menu():\\n MenuData = [\\n (\\\"&Draw Variables\\\",drawable.ask),\\n (\\\"&Show Variables\\\",printall),\\n (\\\"&Print Variables\\\",printval),\\n (\\\"&Edit Variable\\\",edit),\\n (\\\"&Rename Variable\\\",rename),\\n (\\\"&Forget Variables\\\",forget),\\n (\\\"---\\\",None),\\n (\\\"&Create Plane\\\",\\n [(\\\"Coordinates\\\", \\n [(\\\"Point and normal\\\", createPlaneCoordsPointNormal),\\n (\\\"Three points\\\", createPlaneCoords3Points),\\n ]), \\n (\\\"Visually\\\", \\n [(\\\"Three points\\\", createPlaneVisual3Points),\\n ]),\\n ]),\\n (\\\"&Select Plane\\\",planes.ask),\\n (\\\"&Draw Selection\\\",planes.draw),\\n (\\\"&Forget Selection\\\",planes.forget),\\n (\\\"---\\\",None),\\n (\\\"&Pick Actors\\\",pick_actors),\\n (\\\"&Pick Elements\\\",pick_elements),\\n (\\\"&Pick Points\\\",pick_points),\\n (\\\"&Pick Edges\\\",pick_edges),\\n (\\\"---\\\",None),\\n ('&Selection',\\n [('&Create Report',report_selection),\\n ('&Set Property',setprop_selection),\\n ('&Grow',grow_selection),\\n ('&Partition',partition_selection),\\n ('&Get Partition',get_partition),\\n ('&Export',export_selection),\\n ]),\\n (\\\"---\\\",None),\\n ('&Query',\\n [('&Actors',query_actors),\\n ('&Elements',query_elements),\\n ('&Points',query_points),\\n ('&Edges',query_edges),\\n ('&Distances',query_distances),\\n ]),\\n (\\\"---\\\",None),\\n (\\\"&Close\\\",close_menu),\\n ]\\n return widgets.Menu('Tools',items=MenuData,parent=GD.gui.menu,before='help')\",\n \"def newConnection(self, btnParent = None):\\n selected = cmds.ls(selection = True) #current selection\\n\\n if btnParent != None: #display button\\n parent = btnParent\\n selected = []\\n else: #make parent current tab\\n parent = tab = self.tabwidget.currentWidget()\\n\\n btnColor = self.color.currentText() #button color\\n btnName = self.nameBox.text() #button name\\n return self.newDragBtn(btnColor, selected, btnName, parent, self.btnWidth.value(), self.btnHeight.value(), self.tabwidget.currentWidget())\",\n \"def sir_model():\\n ddpp = rmf.DDPP()\\n ddpp.add_transition([-1,1,0],lambda x:x[0]+2*x[0]*x[1])\\n ddpp.add_transition([0,-1,+1],lambda x:x[1])\\n ddpp.add_transition([1,0,-1],lambda x:3*x[2]**3)\\n ddpp.set_initial_state([.3,.2,.5]) # We first need to define an initial stater\\n return ddpp\",\n \"def __getSelectionFilter(self):\\n \\n selectionPairs = []\\n selectionPairs.append(('field','field'))\\n selectionPairs.append(('spw','spw'))\\n selectionPairs.append(('polarization','correlation'))\\n selectionPairs.append(('baseline','antenna'))\\n selectionPairs.append(('time','timerange'))\\n selectionPairs.append(('scan','scan'))\\n selectionPairs.append(('uvdist','uvrange'))\\n selectionPairs.append(('scanintent','intent'))\\n selectionPairs.append(('observation','observation'))\\n return self.__generateFilter(selectionPairs)\",\n \"def sel(\\n self,\\n **kwargs,\\n ) -> \\\"Dataset\\\":\\n res = [da.sel(**kwargs) for da in self]\\n return Dataset(data=res, validate=False)\",\n \"def PricingStartCurvesVector(builder, numElems):\\n return StartCurvesVector(builder, numElems)\",\n \"def _get_button_region(self):\\n # XXXX Only rectangulars for now\\n if not self._sensitive:\\n return None\\n if not self._insidetemporal():\\n return None\\n rgn = Qd.NewRgn()\\n if self._shape == 'rect':\\n x0, y0 = self._convert_point(self._coordinates[0:2])\\n x1, y1 = self._convert_point(self._coordinates[2:4])\\n box = x0, y0, x1, y1\\n Qd.RectRgn(rgn, box)\\n elif self._shape == 'poly':\\n Qd.OpenRgn()\\n xl, yl = self._convert_point(self._coordinates[-2:])\\n Qd.MoveTo(xl, yl)\\n for i in range(0, len(self._coordinates), 2):\\n x, y = self._convert_point(self._coordinates[i:i+2])\\n Qd.LineTo(x, y)\\n Qd.CloseRgn(rgn)\\n elif self._shape == 'circle':\\n print 'Circle not supported yet'\\n elif self._shape == 'ellipse':\\n # Note: rx/ry are width/height, not points\\n x, y, rx, ry = self._dispobj._window._convert_coordinates(self._coordinates)\\n Qd.OpenRgn()\\n Qd.FrameOval((x-rx, y-ry, x+rx, y+ry))\\n Qd.CloseRgn(rgn)\\n else:\\n print 'Invalid shape type', self._shape\\n return rgn\",\n \"def selection(self):\\r\\n if not self._selection:\\r\\n print(\\\"not working\\\")\\r\\n return None\\r\\n\\r\\n year, month = self._date.year, self._date.month\\r\\n if len(str(month))==1:\\r\\n month = \\\"0{}\\\".format(month)\\r\\n return (\\\"{}{}{}\\\".format(year, month, self._selection[0]), \\r\\n \\\"{} / {} / {}\\\".format(year, month, self._selection[0]))\",\n \"def range(self, event):\\r\\n \\r\\n p = (event.x, self.toCartesian(event.y))\\r\\n \\r\\n if self.selectedRegion is None:\\r\\n self.selectedStart = Region(p[X],p[Y], p[X],p[Y])\\r\\n self.selectedRegion = self.selectedStart.unionPoint(p)\\r\\n \\r\\n self.paint()\\r\\n \\r\\n # return (node,sub-tree) where sub-tree is True if draining entire tree\\r\\n # rooted at node. Draw these as shaded red rectangle to identify whole\\r\\n # sub-tree is selected.\\r\\n for pair in self.tree.range(self.selectedRegion):\\r\\n p = pair[0].point\\r\\n \\r\\n if pair[1]:\\r\\n self.canvas.create_rectangle(pair[0].region.x_min, self.toTk(pair[0].region.y_min), \\r\\n pair[0].region.x_max, self.toTk(pair[0].region.y_max),\\r\\n fill='Red', stipple='gray12')\\r\\n else:\\r\\n self.canvas.create_rectangle(p[X] - BoxSize, self.toTk(p[Y]) - BoxSize, \\r\\n p[X] + BoxSize, self.toTk(p[Y]) + BoxSize, fill='Red')\\r\\n\\r\\n self.queryRect = self.canvas.create_rectangle(self.selectedRegion.x_min, self.toTk(self.selectedRegion.y_min), \\r\\n self.selectedRegion.x_max, self.toTk(self.selectedRegion.y_max), \\r\\n outline='Red', dash=(2, 4))\",\n \"def ipset_one_x_new():\\n x = np.linspace(-3, 3, 11)\\n return IPSet(x=x, y=x ** 2, x_new=1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63153064","0.5997607","0.5657909","0.5577311","0.55091554","0.5479855","0.52665573","0.5263441","0.51841724","0.5104352","0.50552374","0.49336368","0.49273384","0.49023122","0.4876281","0.48567244","0.4838079","0.48378935","0.47973046","0.47966853","0.47885236","0.47756404","0.4732002","0.47064656","0.47033882","0.4684112","0.46776748","0.46765655","0.4668958","0.46572882","0.4645869","0.46425867","0.4634486","0.46281308","0.46130538","0.46108025","0.45868474","0.45774594","0.45774594","0.4575116","0.45629814","0.45529646","0.45523158","0.4550593","0.45445558","0.45402125","0.4531364","0.4527998","0.45271552","0.45211455","0.45209572","0.4508082","0.4505488","0.4503868","0.45015427","0.4500083","0.4499608","0.44820884","0.44782865","0.4473344","0.4465156","0.44634694","0.4454673","0.44429997","0.44306546","0.44217092","0.44119287","0.44084087","0.44029078","0.44012365","0.43855557","0.43846485","0.43824124","0.43763396","0.43762296","0.43755993","0.43751","0.43635476","0.43619356","0.43601176","0.43601176","0.43601176","0.43601176","0.43601176","0.43601176","0.43601176","0.43601176","0.43601176","0.43566158","0.4355648","0.43526277","0.4348245","0.4346432","0.43442172","0.4333623","0.43322158","0.43275386","0.43261766","0.432205","0.43213907"],"string":"[\n \"0.63153064\",\n \"0.5997607\",\n \"0.5657909\",\n \"0.5577311\",\n \"0.55091554\",\n \"0.5479855\",\n \"0.52665573\",\n \"0.5263441\",\n \"0.51841724\",\n \"0.5104352\",\n \"0.50552374\",\n \"0.49336368\",\n \"0.49273384\",\n \"0.49023122\",\n \"0.4876281\",\n \"0.48567244\",\n \"0.4838079\",\n \"0.48378935\",\n \"0.47973046\",\n \"0.47966853\",\n \"0.47885236\",\n \"0.47756404\",\n \"0.4732002\",\n \"0.47064656\",\n \"0.47033882\",\n \"0.4684112\",\n \"0.46776748\",\n \"0.46765655\",\n \"0.4668958\",\n \"0.46572882\",\n \"0.4645869\",\n \"0.46425867\",\n \"0.4634486\",\n \"0.46281308\",\n \"0.46130538\",\n \"0.46108025\",\n \"0.45868474\",\n \"0.45774594\",\n \"0.45774594\",\n \"0.4575116\",\n \"0.45629814\",\n \"0.45529646\",\n \"0.45523158\",\n \"0.4550593\",\n \"0.45445558\",\n \"0.45402125\",\n \"0.4531364\",\n \"0.4527998\",\n \"0.45271552\",\n \"0.45211455\",\n \"0.45209572\",\n \"0.4508082\",\n \"0.4505488\",\n \"0.4503868\",\n \"0.45015427\",\n \"0.4500083\",\n \"0.4499608\",\n \"0.44820884\",\n \"0.44782865\",\n \"0.4473344\",\n \"0.4465156\",\n \"0.44634694\",\n \"0.4454673\",\n \"0.44429997\",\n \"0.44306546\",\n \"0.44217092\",\n \"0.44119287\",\n \"0.44084087\",\n \"0.44029078\",\n \"0.44012365\",\n \"0.43855557\",\n \"0.43846485\",\n \"0.43824124\",\n \"0.43763396\",\n \"0.43762296\",\n \"0.43755993\",\n \"0.43751\",\n \"0.43635476\",\n \"0.43619356\",\n \"0.43601176\",\n \"0.43601176\",\n \"0.43601176\",\n \"0.43601176\",\n \"0.43601176\",\n \"0.43601176\",\n \"0.43601176\",\n \"0.43601176\",\n \"0.43601176\",\n \"0.43566158\",\n \"0.4355648\",\n \"0.43526277\",\n \"0.4348245\",\n \"0.4346432\",\n \"0.43442172\",\n \"0.4333623\",\n \"0.43322158\",\n \"0.43275386\",\n \"0.43261766\",\n \"0.432205\",\n \"0.43213907\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5291082"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":7396,"cells":{"query":{"kind":"string","value":"Create and return a D > D0 pi Selection object."},"document":{"kind":"string","value":"def makePseudoPsi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n _daugCuts = \"(PT> %(D0PtLoose)s*MeV)\" % locals()['config']\n _combCuts = \"(APT> %(D0PtLoose)s*MeV)\" % locals()['config']\n\n _Psi = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"D0\": _daugCuts }\n , CombinationCut = _combCuts\n , MotherCut = \"(VFASPF(VCHI2PDOF) < 10000)\"\n )\n\n return Selection( name+'Sel',\n Algorithm = _Psi,\n RequiredSelections = inputSel\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def makeDstar2D0Pi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )","def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\n #\n ## check existing selection\n #\n sel = self._selection ( sel_tag )\n if sel : return sel \n\n #\n ## adjust a bit the arguments\n if not kwargs.has_key('Preambulo') :\n kwargs ['Preambulo' ] = self['Preambulo']\n\n if not kwargs.has_key( 'ParticleCombiners' ) :\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \n \n # \n ## use \"simple-selection\"\n #\n from PhysSelPython.Wrappers import SimpleSelection\n sel = SimpleSelection (\n sel_name ,\n algotype ,\n inputs , \n *args ,\n **kwargs )\n # \n return self._add_selection( sel_tag , sel )","def from_selection(cls):\n guid = compas_rhino.select_point()\n return cls.from_guid(guid)","def create(cls, selection):\n\t\t\n\t\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })","def from_selection(\n class_,\n selection,\n item_class=None,\n ):\n import abjad\n pitch_segment = abjad.PitchSegment.from_selection(selection)\n return class_(\n pitch_segment,\n item_class=item_class,\n )","def makeDefault(name,inputSel) :\n from Configurables import OfflineVertexFitter\n Detached4mu = CombineParticles(\"Combine\"+name)\n Detached4mu.DecayDescriptor = \"B_s0 -> mu+ mu- mu+ mu-\"\n # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:\n Detached4mu.addTool( OfflineVertexFitter )\n Detached4mu.ParticleCombiners.update( { \"\" : \"OfflineVertexFitter\"} )\n Detached4mu.OfflineVertexFitter.useResonanceVertex = False\n Detached4mu.ReFitPVs = True\n Detached4mu.DaughtersCuts = { \"mu+\" : \"(TRCHI2DOF < 2.5 ) \"\\\n \" & (MIPCHI2DV(PRIMARY)> 9.)\"}\n \n Detached4mu.CombinationCut = \"(ADAMASS('B_s0')<1000*MeV) \"\\\n \"& (AMAXDOCA('')<0.3*mm)\"\n Detached4mu.MotherCut = \"(VFASPF(VCHI2/VDOF)<9) \"\\\n \"& (BPVDIRA > 0) \"\\\n \"& (BPVVDCHI2>100)\"\\\n \" & (M>4366.3) & (M<6366.3)\"\\\n \"& (BPVIPCHI2()< 25) \"\n \n\n return Selection (name,\n Algorithm = Detached4mu,\n RequiredSelections = inputSel)","def make_odorant_selector(name):\n return dcc.Input(\n id=\"cid_%s\" % name,\n placeholder=\"Enter a PubChem ID number...\",\n type=\"number\",\n value=None,\n )","def createSelector(self,type='select',speed=2.0):\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector.hide()\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def __init__(self,initial_v,v_select=0,max_dev_semitones=1):\n self.v=initial_v\n self.v_select=v_select\n self.max_dev_semitones=max_dev_semitones","def __init__(self):\n super().__init__()\n self.p = 0.0\n self.type = 'Geometric'\n self.distType = 'Discrete'\n self.lowerBound = 0.0\n self.upperBound = 1.0\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def __init__(self, pvID, pvP, pvQ, pvDescriptor):\n\n # TODO: implement this","def makeDstarPartial( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n dstarCuts = \"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\" \\\n \"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\" % locals()['config']\n\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\n , DaughtersCuts = { \"pi+\" : daugCuts }\n , CombinationCut = combCuts\n , MotherCut = dstarCuts\n )\n\n return Selection( name+'Sel',\n Algorithm = _Dstar,\n RequiredSelections = inputSel\n )","def from_selection(cls):\n guid = compas_rhino.select_mesh()\n return cls.from_guid(guid)","def createSelector2(self,type='select',speed=2.0):\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\n self.selector2.hide()\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\n ival.loop()","def __init__(self):\n super().__init__()\n self.p = 0.0\n self.type = 'Bernoulli'\n self.distType = 'Discrete'\n self.lowerBound = 0.0\n self.upperBound = 1.0\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def __init__(self, P, I, D, dt):\n\n\t\tself._Kp = P\n\t\tself._Ki = I\n\t\tself._Kd = D\n\t\tself._dt = dt","def curve_through_selection(*args):\n sel = cmds.ls(sl=True, fl=True)\n if not sel or len(sel)==1:\n cmds.warning(\"You need to select multiple things to create curve through!\")\n return()\n\n pList = []\n crvType = cmds.radioButtonGrp(widgets[\"crvSelRBG\"], q=True, sl=True)\n\n for obj in sel:\n if cmds.objectType(obj) in [\"transform\"]:\n pos = cmds.xform(obj, q=True, ws=True, rp=True)\n pList.append(pos)\n elif obj in cmds.filterExpand(sm=[28, 30, 31, 32, 34, 46]):\n pos = cmds.pointPosition(obj)\n pList.append(pos)\n\n #add points if only 2 (cv, ep) or 3 (cv) are given, and create the curve\n if crvType == 1:\n if len(pList) == 2:\n f = [float(sum(x)/2) for x in zip(*pList)]\n pList.insert(1, f)\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\n pList.insert(1, newPt1)\n pList.insert(3, newPt2)\n if len(pList) == 3:\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\n pList.insert(1, newPt1)\n pList.insert(3, newPt2)\n crv = cmds.curve(d=3, p=pList, name=\"newCurve\")\n\n if crvType == 2:\n if len(pList) == 2:\n f = [float(sum(x)/2) for x in zip(*pList)]\n pList.insert(1, f)\n crv = cmds.curve(d=3, ep=pList, name=\"newCurve\")\n\n return(crv)","def __init__(\n self, name: str, values: List[Dict], index: Optional[int] = 0,\n label: Optional[str] = None, help: Optional[str] = None,\n default: Optional[bool] = None, required: Optional[bool] = False,\n group: Optional[str] = None\n ):\n super(Select, self).__init__(\n dtype=PARA_SELECT,\n name=name,\n index=index,\n label=label,\n help=help,\n default=default,\n required=required,\n group=group\n )\n self.values = values","def build_selection_spec(client_factory, name):\r\n sel_spec = client_factory.create('ns0:SelectionSpec')\r\n sel_spec.name = name\r\n return sel_spec","def __init__(self):\n super().__init__()\n self.n = 0.0\n self.p = 0.0\n self.type = 'Binomial'\n self.hasInfiniteBound = True\n self.distType = 'Discrete'\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def select(self):\n\t\tbest_num_components = self.n_constant\n\t\treturn self.base_model(best_num_components)","def pdos_select(self, atoms=None, spin=None, l=None, m=None):\n valid_m_values = {'s': [],\n 'p': ['x', 'y', 'z'],\n 'd': ['xy', 'yz', 'z2-r2', 'xz', 'x2-y2'],\n 'f': ['y(3x2-y2)', 'xyz', 'yz2', 'z3', 'xz2', 'z(x2-y2)', 'x(x2-3y2)']}\n if not atoms:\n atom_idx = list(range(self.number_of_atoms))\n else:\n atom_idx = atoms\n to_return = self.pdos_raw[atom_idx, :, :, :]\n if not spin:\n spin_idx = list(range(self.ispin))\n elif spin == 'up':\n spin_idx = [0]\n elif spin == 'down':\n spin_idx = [1]\n elif spin == 'both':\n spin_idx = [0, 1]\n else:\n raise ValueError\n to_return = to_return[:, :, :, spin_idx]\n\n if not l:\n channel_idx = list(range(self.number_of_channels))\n elif l == 's':\n channel_idx = [0]\n elif l == 'p':\n if not m:\n channel_idx = [1, 2, 3]\n else:\n channel_idx = [1 + i for i, v in enumerate(valid_m_values['p']) if v in m]\n elif l == 'd':\n if not m:\n channel_idx = [4, 5, 6, 7, 8]\n else:\n channel_idx = [4 + i for i, v in enumerate(valid_m_values['d']) if v in m]\n elif l == 'f':\n if not m:\n channel_idx = [9, 10, 11, 12, 13, 14, 15]\n else:\n channel_idx = [9 + i for i, v in enumerate(valid_m_values['f']) if v in m]\n else:\n raise ValueError\n\n return to_return[:, :, channel_idx, :]","def __init__(self, parent):\n # parent is the main frame of PyCorrFit\n self.parent = parent\n ## MYID\n # This ID is given by the parent for an instance of this class\n self.MyID = None\n ## Wrapping\n curvedict, labels = self.GetCurvedict()\n self.labels = labels\n self.Selector = UserSelectCurves(parent, curvedict,\n wrapper=self, labels=labels)\n # This is necessary for parent to deselect and select the tool\n # in the tools menu.\n self.Bind = self.Selector.Bind\n if self.parent.notebook.GetPageCount() == 0:\n self.Selector.sp.Disable()","def __init__(self, p) -> None:\n self._p = p\n self._delegate = TwoQubitAsymmetricDepolarizingChannel(p / 15, p / 15, p / 15,\n p / 15, p / 15, p / 15,\n p / 15, p / 15, p / 15,\n p / 15, p / 15, p / 15,\n p / 15, p / 15, p / 15)","def _an_element_(self):\n from sage.rings.integer_ring import ZZ\n return self(self.realization_of().PD().get_point(ZZ.zero()))","def 选择项目(self, n): # real signature unknown; restored from __doc__\n return self.Select(n)","def _select_single(self, disc):\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)","def __init__(self, r=1, p=3):\n self.p = p\n self.r = r","def generate_kdtree(self):\n if self.method==2:\n coordinates = self.unassigned_data[0:3,:]\n else:\n coordinates = self.unassigned_data[0:2,:]\n tree = cKDTree(coordinates.T)\n\n return tree","def make_selection(self, num):\n other_doors = None\n if num is 1:\n other_doors = [str(2), str(3)]\n elif num is 2:\n other_doors = [str(1), str(3)]\n elif num is 3:\n other_doors = [str(1), str(2)]\n\n reveal = str(random.choice(other_doors))\n other_doors.remove(reveal)\n third_door = random.choice(other_doors)\n other_doors.remove(third_door)\n\n main_door = getattr(self, 'door' + str(num) + '_counter')\n door_second = getattr(self, 'door' + reveal + '_counter')\n door_third = getattr(self, 'door' + third_door + '_counter')\n main_door_reveal = getattr(self, 'door'+str(num)+'_reveal')\n\n if (main_door is 0 and door_second is 0\n and door_third is 0):\n self.ids['door'+reveal].source = \\\n getattr(self, 'door'+reveal+'_reveal')\n self.ids['button'+reveal].disabled = True\n inc = getattr(self, 'door' + str(num) + '_counter')\n setattr(self, 'door' + str(num) + '_counter', inc + 1)\n elif main_door is 1 and door_second is 0 and door_third is 0:\n for i in range(1, 4, 1):\n self.ids['door' + str(i)].source = \\\n getattr(self, 'door' + str(i) + '_reveal')\n self.ids['button'+str(i)].disabled = True\n if main_door_reveal in ['door-money.png']:\n self.win_popup()\n else:\n self.lose_popup()\n elif main_door is 0 and (door_second is 1 or door_third is 1):\n for i in range(1, 4, 1):\n self.ids['door' + str(i)].source = \\\n getattr(self, 'door' + str(i) + '_reveal')\n self.ids['button'+str(i)].disabled = True\n if main_door_reveal in ['door-money.png']:\n self.win_popup()\n else:\n self.lose_popup()","def get_selection():\n\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\n sel_len = len(selected)\n result = SelectionContainer()\n\n for _x in range(0, sel_len):\n\n shape_type = selected[_x].ShapeType\n\n if shape_type == 'Vertex':\n result.vertices.append(selected[_x])\n\n elif shape_type == 'Edge':\n\n if 'Line' in str(selected[_x].Curve):\n result.lines.append(selected[_x])\n else:\n result.curves.append(selected[_x])","def __init__(self, disk_radius=None, even_sampling=False, no_data_value=None, ignore_labels=None):\n self.disk_radius = disk_radius\n self.ignore_labels = [] if ignore_labels is None else ignore_labels\n self.even_sampling = even_sampling\n self.no_data_value = no_data_value","def initP0(self, size, radius):\n return h.circle(size, radius)[:, :, 0]","def selection(self):\n # create an empty priority queue for the new generation\n newGeneration = PriorityQueue()\n # pick top X of the population to survive\n for c in range(0, self.generation.qsize() / SELECTION_FRACTION):\n # get a chromosome\n chromosome = self.generation.get()\n # put the chromosomes in the new generation\n newGeneration.put(chromosome)\n # keep the new generation\n self.generation = newGeneration","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def __init__(self, *args, **kwargs):\n _gdi_.PseudoDC_swiginit(self,_gdi_.new_PseudoDC(*args, **kwargs))","def __init__(self,min_instances=30, drift_level=3.0):\n\n from math import sqrt\n self.min_instances = min_instances\n self.drift_level = float(drift_level)\n self.i = None\n self.pi = None\n self.si = None\n self.pi_min = None\n self.si_min = None\n self.sqrt=sqrt\n self.reset()","def __init__(self):\n super().__init__()\n self.mu = 0.0\n self.type = 'Poisson'\n self.hasInfiniteBound = True\n self.distType = 'Discrete'\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def _create_example_door():\n return Door({\"warning\": False, \"closed\": True, \"locked\": False})","def construct_random_initial(self):\n x = np.random.random((self._crv_size, self._bound))\n return x","def pool_selected( self, object ):\n\t\tud.debug( ud.ADMIN, ud.INFO, 'UVMM.DW.ps(node_uri=%s)' % self.node_uri)\n\t\tpool_name = object.options.get('pool-name')\n\t\tif not pool_name:\n\t\t\tpool_name = object.options['pool-name'] = 'default'\n\t\tdrive_type = object.options['drive-type']\n\t\ttry:\n\t\t\tif drive_type == 'cdrom':\n\t\t\t\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'cdrom')\n\t\t\telse:\n\t\t\t\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'disk' )\n\t\texcept uvmmd.UvmmError, e:\n\t\t\tvols = ()\n\t\tud.debug(ud.ADMIN, ud.INFO, 'UVMM.DW.ps: volumes=%s' % map(str, vols))\n\t\tchoices = []\n\t\tfor vol in vols:\n\t\t\tbasename = os.path.basename( vol.source )\n\t\t\tif '.' in basename:\n\t\t\t\tsuffix = basename[ basename.rfind( '.' ) + 1 : ]\n\t\t\t\tif suffix in ( 'xml', 'snapshot' ):\n\t\t\t\t\tcontinue\n\t\t\tchoices.append( basename )\n\t\tchoices.sort()\n\t\tself.image_syntax.update_choices( choices )\n\n\t\t# recreate pool button\n\t\tbtn = self._create_pool_select_button( object.options )\n\t\tself[DriveWizard.PAGE_OLD].options[0] = btn\n\t\tself[DriveWizard.PAGE_NEW].options[0] = btn\n\t\t# recreate driver-type button\n\t\titems = [self[DriveWizard.PAGE_NEW].options[2].id(), self[DriveWizard.PAGE_NEW].options[3].id()]\n\t\tbtn = self._create_type_select_button(object.options, items)\n\t\tself[DriveWizard.PAGE_NEW].options[1] = btn\n\n\t\tif drive_type == 'disk':\n\t\t\tself[DriveWizard.PAGE_OLD].hint = None\n\t\telif drive_type in ( 'cdrom', 'floppy' ):\n\t\t\tif self.image_syntax._choices:\n\t\t\t\tmsg = _( \"If the required image is not found it might be added by copying the file into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\" )\n\t\t\telse:\n\t\t\t\tmsg = _( \"The list of available images is empty! To add an image the file needs to be copied into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\" )\n\t\t\tself[DriveWizard.PAGE_OLD].hint = msg\n\t\t\tself[DriveWizard.PAGE_OLD].description = ''\n\t\telse:\n\t\t\traise ValueError('Invalid drive-type \"%s\"' % drive_type)\n\n\t\treturn self.type_selected(object)","def __make_slide(self):\n # Create base rectangle for slide\n length = self.parameters['slide_base_length'] + self.parameters['bearing_slide_travel']\n width = self.parameters['slide_width']\n height = self.parameters['slide_height']\n slide = fso.Box(x=length,y=width,z=height)\n # Create the mounting holes\n radius = 0.5*self.parameters['slide_screw_size']\n base_hole = fso.Cylinder(r=radius, l=2*height)\n hole_list = []\n for i in (-1,1):\n for j in (-1,1):\n xpos = i*(0.5*length - self.parameters['slide_screw_inset'])\n ypos = j*(0.5*self.parameters['slide_screw_dW'])\n hole = base_hole.copy()\n hole.translate([xpos,ypos,0])\n hole_list.append(hole)\n # Remove hole material\n slide -= hole_list\n slide.set_color(self.slide_color,recursive=True)\n self.slide = slide","def __init__(self, r1=4.5*0.0254, r2=4.5*0.0254,\n d1=25.0*0.0254, d2=25.0*0.0254,\n Ixx=185000.0*0.45359237*0.0254**2,\n Iyy=185000.0*0.45359237*0.0254**2,\n Izz=3500.0*0.45359237*0.0254**2,):\n self.r1 = r1 # m\n self.r2 = r2 # m\n self.d1 = d1 # m\n self.d2 = d2 # m\n self.Ixx = Ixx # kg-m^2\n self.Iyy = Iyy # kg-m^2\n self.Izz = Izz # kg-m^2","def selection(self):\n if not self._selection:\n return None\n \n year, month = self._date.year, self._date.month\n return self.datetime(year, month, int(self._selection[0]))","def _generate_solution(self):\n \n operation_list = []\n available = {job.get_job_id(): [operation for operation in job.get_operations() if operation.get_sequence() == 0] for job in self.jssp_instance_data.jobs} # dictionary of first unprocessed operations of each job\n \n while 0 < len(available):\n rand_job_id = random.choice(list(available.keys()))\n rand_operation = random.choice(available[rand_job_id])\n rand_machine = np.random.choice(rand_operation.get_required_machines())\n\n available[rand_job_id].remove(rand_operation)\n \n if len(available[rand_job_id]) == 0:\n # if selected operation is last operation of the job \n if rand_operation.get_sequence() == self.jssp_instance_data.get_job(rand_job_id).get_max_sequence():\n del available[rand_job_id]\n else:\n available[rand_job_id] = [t for t in self.jssp_instance_data.get_job(rand_job_id).get_operations() if\n t.get_sequence() == rand_operation.get_sequence() + 1]\n\n\n operation_list.append([rand_job_id, rand_operation.get_operation_id(), rand_operation.get_sequence(), rand_machine]) # chromosome representation \n return Solution(self.jssp_instance_data, np.array(operation_list, dtype=np.intc))","def __init__(self, dict = {}):\r\n if dict == {}:\r\n self.zero_val()\r\n else:\r\n self.piDD = dict\r\n self.top_node = utilities.max_length_in_list(self.return_keys())\r\n if self.piDD[self.top_node] == None:\r\n self.dim = 0\r\n else:\r\n self.dim = self.piDD[self.top_node][0][0]","def __init__(self):\n\n self.P = list()\n self.label = 0","def __init__(self, radius=0.5, extra={}):\n self.radius = radius\n self.sensors = [] # array of Attached\n self.id_sensors = None\n self.id_dynamics = None # XXX\n self.dynamics = None\n self.extra = extra\n\n self.primitives = set()\n\n # Needs to be initialized before calling certain functions\n self._state = None","def __init__(self):\n raise NotImplementedError('cannot create independent arc')","def eta23pi ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays\n ## \n pre_eta = self.make_selection (\n ## the unique tag \n 'PreEta3Pi' ,\n ## algorithm type to be used\n DaVinci__N3BodyDecays ,\n ## input selections \n [ self.pions () , self.pi0 () ] ,\n ## algorithm properties \n DecayDescriptor = \" eta -> pi+ pi- pi0\" ,\n ## \n Combination12Cut = \"\"\" ( AM < 700 * MeV ) &\n ( ACHI2DOCA(1,2) < 12 ) \n \"\"\" , \n ##\n CombinationCut = \"\"\"\n ( APT > %s ) & ( ADAMASS ( 'eta' ) < 100 * MeV )\n \"\"\" % ( 0.9 * self['ETA_PT'] ) ,\n ##\n MotherCut = \"\"\"\n ( PT > %s ) &\n ( chi2vx < 9 ) \n \"\"\" % self['ETA_PT']\n )\n ##\n from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger2g\n ## \n return self.make_selection (\n 'Eta23pi' ,\n Pi0Veto__Tagger2g ,\n [ pre_eta ] ,\n MassWindow = 25 * MeV ,\n MassChi2 = -1 ,\n ExtraInfoIndex = 25016 ## unique ! \n )","def _select(self):\n sel = []\n\n # choose randomly while favouring fit individuals\n lp = len(self.population) // 2\n for _ in range(lp):\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n while idx1 == idx2:\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n\n p1, p2 = self.population[idx1], self.population[idx2]\n sel.append((p1, p2))\n\n return sel","def __init__(self, d):\n\t\tself._coords = [0] * d","def test_non_it(self):\n self.idx = [9, 11, 6, 10, 12, 2, 8, 1, 5, 0, 7, 4, 3]\n selector = PCovCUR(n_to_select=12, iterative=False)\n selector.fit(self.X, self.y)\n\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))","def __init__(self):\n\n # Assign a nullptr for the device-side pointers. These will be set if the GPU is utilized.\n self.ng = int(0)\n self.goals = ct.POINTER(ct.c_uint)()\n self.currentHorizon = int(0)\n self.V = ct.POINTER(ct.c_float)()\n self.VPrime = ct.POINTER(ct.c_float)()\n self.pi = ct.POINTER(ct.c_uint)()\n self.ne = int(0)\n self.expanded = ct.POINTER(ct.c_int)()\n self.d_goals = ct.POINTER(ct.c_uint)()\n self.d_S = ct.POINTER(ct.c_int)()\n self.d_T = ct.POINTER(ct.c_float)()\n self.d_R = ct.POINTER(ct.c_float)()\n self.d_V = ct.POINTER(ct.c_float)()\n self.d_VPrime = ct.POINTER(ct.c_float)()\n self.d_pi = ct.POINTER(ct.c_uint)()\n self.d_expanded = ct.POINTER(ct.c_int)()\n\n # Additional informative variables.\n self.Rmin = None\n self.Rmax = None","def selected_choice(self):\r\n choice = zeros(self.num_agents)\r\n random_numbers = self.generate_random_numbers()\r\n\r\n self.prob_cumsum = self.cumprob().filled(-1)\r\n\r\n for i in range(self.num_choices):\r\n # Indicator for the zero cells in the choice array\r\n #indicator_zero_cells = ones(self.num_agents)\r\n indicator = array([True]*self.num_agents)\r\n\r\n zero_indices = choice == 0\r\n #indicator_zero_cells[~zero_indices] = ma.masked\r\n indicator[~zero_indices] = False\r\n\r\n # Indicator for the cells where the random number\r\n # is less than the probability\r\n #indicator_less_cells = ones(self.num_agents)\r\n #indicator_less_cells = array([True]*self.num_agents)\r\n less_indices = random_numbers < self.prob_cumsum[:,i]\r\n #indicator_less_cells[~less_indices] = ma.masked\r\n #indicator_less_cells\r\n indicator[~less_indices] = False\r\n\r\n\r\n #indicator_less_zero_cells = indicator_zero_cells + indicator_less_cells\r\n\r\n #indicator_less_zero_cells = indicator_less_zero_cells == 2\r\n\r\n choice[indicator] = i + 1\r\n\r\n choice.shape = (self.num_agents, 1)\r\n\r\n #alt_text = []\r\n #for i in choice:\r\n # alt_text.append(self.choices[int(i[0])-1])\r\n #alt_text = array(alt_text)\r\n #alt_text.shape = (self.num_agents, 1)\r\n\r\n #return alt_text\r\n #print choice\r\n return DataArray(choice, ['selected choice'])","def __init__(self, analogue_selection='indep', clock_selection='in', cal_mode='no_cal', clk_speed=800):\n self.value = 0\n self.value |= (0b1 << 2) # disable chip version output bit\n self.value |= (0b1 << 3) # set demux to 1:2\n clk_bits = 0b00 if (clk_speed<125) else 0b01 if (clk_speed<250) else 0b10 if (clk_speed<500) else 0b11\n self.value |= (clk_bits << 12) # control wait bit calibration value is dependent on clk speed\n self.value |= (1 << 14) # set FDataReady to Fs/2. I don't know what this means\n self.set_analogue_selection(analogue_selection)\n self.set_clock_selection(clock_selection)\n self.set_cal_mode(cal_mode)","def pi(self):\n return self(self._real_field().pi())","def __init__(self):\n super().__init__()\n self.lambdaVar = 1.0\n self.low = 0.0\n self.type = 'Exponential'\n self.distType = 'Continuous'\n self.hasInfiniteBound = True\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def __init__(self, params):\r\n _params = {'Similarity': 0.97,\r\n 'Application': 'cdhit',\r\n 'Algorithm': 'cdhit: \"longest-sequence-first list removal algorithm\"'}\r\n _params.update(params)\r\n OtuPicker.__init__(self, _params)","def __init__(self, goal=0, kP=1, kI=1, kD=1, init_pt=0):\n self._pid_lock = threading.Lock()\n\n self.set_goal(goal)\n self.reset(init_pt)\n self.set_gains({\n PIDController.KP_KEY: kP,\n PIDController.KI_KEY: kI,\n PIDController.KD_KEY: kD\n })","def __init__(\n self, voltage={0:(0, 0)}, rate=500, repetitions=1,\n board_name='cDAQ1Mod1', voltage_limits=None, num_channels=7):\n self.board_name = board_name #Check Measurement and Automation Explorer\n self._taskHandle = ctypes.c_void_p(0)\n self.num_channels = num_channels\n DAQmxErrChk(api.DAQmxCreateTask(\"\", ctypes.byref(self._taskHandle)))\n DAQmxErrChk(api.DAQmxCreateAOVoltageChan(\n self._taskHandle,\n self.board_name + \"/ao0:%i\"%(num_channels - 1),\n \"\",\n ctypes.c_double(-10.0), #Minimum voltage\n ctypes.c_double(10.0), #Maximum voltage\n 10348, #DAQmx_Val_Volts; don't question it!\n ctypes.c_void_p(0), #NULL\n ))\n self.num_points_written = ctypes.c_long(0)\n self._unwritten_voltages = False\n self._unplayed_voltages = False\n self.set_voltage_and_timing(voltage, rate, repetitions, voltage_limits)\n return None","def select(self):\n\n return self.p[0], self.p[1]","def null(cls, d=2):\n return cls(*[0 for i in range(d)])","def get_selection(self, selection_name, format=None):","def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\n self.GP = GPIOProcessor()\n self.pin1 = self.GP.getPin(pin1)\n self.pin2 = self.GP.getPin(pin2)\n self.pin3 = self.GP.getPin(pin3)\n self.pin4 = self.GP.getPin(pin4)\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\n\n for k in range(4):\n self.pinl[k].out()\n\n self.speed = 100.0","def circle(self):\n return circle(self.N, self.o, self.r)","def p_selection(p_init, it, n_iters):\n it = int(it / n_iters * 10000)\n\n if 10 < it <= 50:\n p = p_init / 2\n elif 50 < it <= 200:\n p = p_init / 4\n elif 200 < it <= 500:\n p = p_init / 8\n elif 500 < it <= 1000:\n p = p_init / 16\n elif 1000 < it <= 2000:\n p = p_init / 32\n elif 2000 < it <= 4000:\n p = p_init / 64\n elif 4000 < it <= 6000:\n p = p_init / 128\n elif 6000 < it <= 8000:\n p = p_init / 256\n elif 8000 < it <= 10000:\n p = p_init / 512\n else:\n p = p_init\n\n return p","def select_arm(self):\n\n # Exploitation\n if random.uniform(0, 1) > self.epsilon:\n return np.argmax(self.values)\n\n # Exploration\n else:\n return random.randrange(len(self.values))","def pick(self):\n\n pickerdict = {}\n current_value = 0\n\n if len(self.choices) == 0:\n return None\n\n if len(self.choices) == 1:\n return self.choices[0][0]\n\n for option in self.choices:\n pickerdict[current_value] = option[0]\n current_value += option[1]\n\n picker = random.randint(0, current_value)\n last_value = 0\n result = None\n sorted_keys = sorted(pickerdict.keys())\n\n found = False\n for key in sorted_keys:\n if key >= picker:\n result = pickerdict[last_value]\n found = True\n continue\n last_value = key\n\n if not found:\n result = pickerdict[sorted_keys[-1]]\n\n return result","def select(self):\n pass","def select(self):\n pass","def __init__(self, choice):\r\n self.choice = choice","def make_car():\n car = Car() \n car.drop_val = random.randint(0,1)\n\n if car.drop_val == 0:\n car.drop_x = random.randint(77, 400) * 2\n\n elif car.drop_val == 1:\n car.drop_y = random.randint(62, 300) *2\n\n return car","def __init__(self, D, K):\n\t\tself.D = D \n\t\tself.K = K \n\t\tself.V = np.zeros((D+1,K))\n\t\treturn","def dropdown(self):\n # defaults = DDConfig(0.6, 0.6, 0, 0)\n return DropDown(self.name, self.command, **self.config)","def __init__(self, inplace=False):\n super(SELU, self).__init__()\n self.inplace = inplace","def __init__(self, motor, OD_range=None, motor_range=None,\n motor_min=None, OD_min=None, motor_max=None, OD_max=None):\n self.motor = motor\n if OD_range is not None:\n self.OD_range = OD_range\n if motor_range is not None:\n self.motor_range = motor_range\n\n if motor_min is not None:\n self.motor_min = motor_min\n else:\n self.motor_min = motor_range[0]\n\n if motor_max is not None:\n self.motor_max = motor_max\n else:\n self.motor_max = motor_range[1]\n\n if OD_min is not None:\n self.OD_min = OD_min\n else:\n self.OD_min = OD_range[0]\n\n if OD_max is not None:\n self.OD_max = OD_max\n else:\n self.OD_max = OD_range[1]","def touching_choice(self,p):\n\n part = ['head', 'foot1', 'foot2', 'foot3', 'foot4', 'back', 'stomach', 'tail']\n if len(self.select[p]) == 0:\n return random.sample(part,2)\n elif len(self.select[p]) == 1:\n part.remove(self.select[p][0])\n c = random.sample(part,1)\n return [self.select[p][0], c[0]]\n else:\n return random.sample(self.select[p],2)","def select(self):\r\n pass","def __init__(self, r: float, i: float = 0):\n self.r = r\n self.i = i","def __init__(self, tpose, mpose, tselect=[], mselect=[]):\n self.target = tpose\n self.mobile = mpose\n self.target_residues = res_selector_to_size_list(tselect)\n self.mobile_residues = res_selector_to_size_list(mselect)\n self.set_target_sequence()\n self.set_mobile_sequence()\n self.atoms = ['N','C','CA']\n self.bb_rmsd = None","def create_soft_cluster():\n # node, index_component, inf_val = general.get_soft_selection()\n soft_element_data = general.get_soft_selection()\n selection = [vtx_component for vtx_component, inf_val in soft_element_data]\n\n pm.select(selection, r=True)\n cluster = pm.cluster(relative=True)\n\n for vtx_component, inf_val in soft_element_data:\n pm.percent(cluster[0], vtx_component, v=inf_val)\n pm.select(cluster[1], r=True)\n\n return cluster","def __init__(self):\n {}\n #generate a monoid Q\n self.monoid_Q = self.generateQ()[0]\n self.relationOfElements_Q = self.generateQ()[1]\n self.p_Position = self.generateQ()[2]\n self.qOfPosition = self.generateQ()[3]\n #print(self.qOfPosition)","def zero_val(self):\r\n self.piDD = {\"[0]\": None}\r\n self.top_node = \"[0]\"\r\n self.dim = 0","def get_slider():\n return dcc.RangeSlider(\n id='hours',\n value=[0, 23],\n min=0,\n max=23,\n marks={i: str(i) for i in range(0, 24, 3)}\n )","def choose_pos(self):\n s = self\n\n availablepos = []\n for dblock in s.pjs.dblocks:\n is_available = True\n\n for powerup in s.pjs.powerups:\n if powerup.rects[0].overlap(dblock.rects[0]):\n is_available = False\n break\n\n if is_available:\n availablepos.append(dblock.rpos)\n\n pos = random.randint(0, len(availablepos) - 1)\n s.rpos = availablepos[pos]","def __init__(self):\n super().__init__()\n self.low = 0.0\n self.high = 1.0\n self.alpha = 0.0\n self.beta = 0.0\n self.type = 'Beta'\n self.distType = 'Continuous'\n self.hasInfiniteBound = True\n self.compatibleQuadrature.append('Jacobi')\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'Jacobi'\n self.preferredPolynomials = 'Jacobi'","def selectPointsUnderCursor(self):\n spw = self.spw\n sw = spw.windows['Sort']\n #if clear:\n # sw.uslist.clearSelection()\n # sw.nlist.clearSelection()\n x, y = self.cursorPosGL()\n sids = self.pick(x, y, pb=10, multiple=True)\n if sids is None:\n return\n #t0 = time.time()\n spw.SelectSpikes(sids, on=self.selecting)\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\n if self.selecting == True:\n sat = 0.2 # desaturate\n else: # self.selecting == False\n sat = 1 # resaturate\n self.color(sids, sat=sat)\n self.updateGL()","def selection(self) -> Chromosome:\n # each chromosome has a fitness, and the lower the fitness, the higher the probability of election\n choices_list = list(range(len(self._population)))\n weights = [1 / chromosome.get_fitness() for chromosome in self._population]\n\n index = choices(choices_list, weights=weights)[0]\n\n return self._population[index]","def create_pressure_vessel_geometry():\r\n\r\n # configure sigmoid function\r\n bounds_upper = [3, 6]\r\n h = 5\r\n w = 6\r\n\r\n sigmoid_function = lambda x: (1 / (1 + np.exp(-1 * h * x + w))) + 1\r\n\r\n sigmoid_function_reverse = lambda x: 1 / (1 + np.exp(h * x - w - 18)) + 1\r\n\r\n funcs_upper = [sigmoid_function, sigmoid_function_reverse]\r\n\r\n bounds_lower = None\r\n funcs_lower = 0\r\n\r\n x_max = 6\r\n x_min = 0\r\n resolution = 10000\r\n\r\n pressure_vessel = Geometry(x_max, x_min, resolution,\r\n bounds_upper, funcs_upper,\r\n bounds_lower, funcs_lower)\r\n\r\n return pressure_vessel","def random(cls, d=2, borns=[-1, 1], **kwargs):\n components = [random.uniform(*borns) for i in range(d)]\n return cls(*components, **kwargs)","def random(cls, d=2, borns=[-1, 1], **kwargs):\n components = [random.uniform(*borns) for i in range(d)]\n return cls(*components, **kwargs)"],"string":"[\n \"def makeDstar2D0Pi( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n daugCuts = \\\"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\\\" % locals()['config']\\n combCuts = \\\"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\\\" % locals()['config']\\n dstarCuts = \\\"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\\\" \\\\\\n \\\"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\\\" % locals()['config']\\n\\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"pi+\\\" : daugCuts }\\n , CombinationCut = combCuts\\n , MotherCut = dstarCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dstar,\\n RequiredSelections = inputSel\\n )\",\n \"def make_selection ( self ,\\n tag , \\n algotype ,\\n inputs , \\n *args ,\\n **kwargs ) :\\n sel_tag = '%s_Selection' % tag\\n sel_name = 'Sel%sFor%s' % ( tag , self.name() )\\n #\\n ## check existing selection\\n #\\n sel = self._selection ( sel_tag )\\n if sel : return sel \\n\\n #\\n ## adjust a bit the arguments\\n if not kwargs.has_key('Preambulo') :\\n kwargs ['Preambulo' ] = self['Preambulo']\\n\\n if not kwargs.has_key( 'ParticleCombiners' ) :\\n kwargs ['ParticleCombiners'] = { '' : 'LoKi::VertexFitter:PUBLIC' } \\n \\n # \\n ## use \\\"simple-selection\\\"\\n #\\n from PhysSelPython.Wrappers import SimpleSelection\\n sel = SimpleSelection (\\n sel_name ,\\n algotype ,\\n inputs , \\n *args ,\\n **kwargs )\\n # \\n return self._add_selection( sel_tag , sel )\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_point()\\n return cls.from_guid(guid)\",\n \"def create(cls, selection):\\n\\t\\t\\n\\t\\treturn cls({ true_selector: selection, false_selector: Selection.invert(selection) })\",\n \"def from_selection(\\n class_,\\n selection,\\n item_class=None,\\n ):\\n import abjad\\n pitch_segment = abjad.PitchSegment.from_selection(selection)\\n return class_(\\n pitch_segment,\\n item_class=item_class,\\n )\",\n \"def makeDefault(name,inputSel) :\\n from Configurables import OfflineVertexFitter\\n Detached4mu = CombineParticles(\\\"Combine\\\"+name)\\n Detached4mu.DecayDescriptor = \\\"B_s0 -> mu+ mu- mu+ mu-\\\"\\n # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:\\n Detached4mu.addTool( OfflineVertexFitter )\\n Detached4mu.ParticleCombiners.update( { \\\"\\\" : \\\"OfflineVertexFitter\\\"} )\\n Detached4mu.OfflineVertexFitter.useResonanceVertex = False\\n Detached4mu.ReFitPVs = True\\n Detached4mu.DaughtersCuts = { \\\"mu+\\\" : \\\"(TRCHI2DOF < 2.5 ) \\\"\\\\\\n \\\" & (MIPCHI2DV(PRIMARY)> 9.)\\\"}\\n \\n Detached4mu.CombinationCut = \\\"(ADAMASS('B_s0')<1000*MeV) \\\"\\\\\\n \\\"& (AMAXDOCA('')<0.3*mm)\\\"\\n Detached4mu.MotherCut = \\\"(VFASPF(VCHI2/VDOF)<9) \\\"\\\\\\n \\\"& (BPVDIRA > 0) \\\"\\\\\\n \\\"& (BPVVDCHI2>100)\\\"\\\\\\n \\\" & (M>4366.3) & (M<6366.3)\\\"\\\\\\n \\\"& (BPVIPCHI2()< 25) \\\"\\n \\n\\n return Selection (name,\\n Algorithm = Detached4mu,\\n RequiredSelections = inputSel)\",\n \"def make_odorant_selector(name):\\n return dcc.Input(\\n id=\\\"cid_%s\\\" % name,\\n placeholder=\\\"Enter a PubChem ID number...\\\",\\n type=\\\"number\\\",\\n value=None,\\n )\",\n \"def createSelector(self,type='select',speed=2.0):\\n self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector.hide()\\n ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def __init__(self,initial_v,v_select=0,max_dev_semitones=1):\\n self.v=initial_v\\n self.v_select=v_select\\n self.max_dev_semitones=max_dev_semitones\",\n \"def __init__(self):\\n super().__init__()\\n self.p = 0.0\\n self.type = 'Geometric'\\n self.distType = 'Discrete'\\n self.lowerBound = 0.0\\n self.upperBound = 1.0\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def __init__(self, pvID, pvP, pvQ, pvDescriptor):\\n\\n # TODO: implement this\",\n \"def makeDstarPartial( name\\n , config\\n , DecayDescriptor\\n , inputSel\\n ) :\\n\\n daugCuts = \\\"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\\\" % locals()['config']\\n combCuts = \\\"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\\\" % locals()['config']\\n dstarCuts = \\\"(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)\\\" \\\\\\n \\\"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)\\\" % locals()['config']\\n\\n _Dstar = CombineParticles( DecayDescriptor = DecayDescriptor\\n , DaughtersCuts = { \\\"pi+\\\" : daugCuts }\\n , CombinationCut = combCuts\\n , MotherCut = dstarCuts\\n )\\n\\n return Selection( name+'Sel',\\n Algorithm = _Dstar,\\n RequiredSelections = inputSel\\n )\",\n \"def from_selection(cls):\\n guid = compas_rhino.select_mesh()\\n return cls.from_guid(guid)\",\n \"def createSelector2(self,type='select',speed=2.0):\\n self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)\\n self.selector2.hide()\\n ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))\\n ival.loop()\",\n \"def __init__(self):\\n super().__init__()\\n self.p = 0.0\\n self.type = 'Bernoulli'\\n self.distType = 'Discrete'\\n self.lowerBound = 0.0\\n self.upperBound = 1.0\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def __init__(self, P, I, D, dt):\\n\\n\\t\\tself._Kp = P\\n\\t\\tself._Ki = I\\n\\t\\tself._Kd = D\\n\\t\\tself._dt = dt\",\n \"def curve_through_selection(*args):\\n sel = cmds.ls(sl=True, fl=True)\\n if not sel or len(sel)==1:\\n cmds.warning(\\\"You need to select multiple things to create curve through!\\\")\\n return()\\n\\n pList = []\\n crvType = cmds.radioButtonGrp(widgets[\\\"crvSelRBG\\\"], q=True, sl=True)\\n\\n for obj in sel:\\n if cmds.objectType(obj) in [\\\"transform\\\"]:\\n pos = cmds.xform(obj, q=True, ws=True, rp=True)\\n pList.append(pos)\\n elif obj in cmds.filterExpand(sm=[28, 30, 31, 32, 34, 46]):\\n pos = cmds.pointPosition(obj)\\n pList.append(pos)\\n\\n #add points if only 2 (cv, ep) or 3 (cv) are given, and create the curve\\n if crvType == 1:\\n if len(pList) == 2:\\n f = [float(sum(x)/2) for x in zip(*pList)]\\n pList.insert(1, f)\\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\\n pList.insert(1, newPt1)\\n pList.insert(3, newPt2)\\n if len(pList) == 3:\\n vec1 = [pList[1][0]-pList[0][0], pList[1][1]-pList[0][1], pList[1][2]-pList[0][2]]\\n newPt1 =[pList[0][0] + (vec1[0]*0.05), pList[0][1] + (vec1[1]*0.05), pList[0][2] + (vec1[2]*0.05)]\\n vec2 = [pList[1][0] - pList[2][0], pList[1][1] - pList[2][1], pList[1][2] - pList[2][2]]\\n newPt2= [pList[2][0] + (vec2[0]*0.05), pList[2][1] + (vec2[1]*0.05), pList[2][2] + (vec2[2]*0.05)]\\n pList.insert(1, newPt1)\\n pList.insert(3, newPt2)\\n crv = cmds.curve(d=3, p=pList, name=\\\"newCurve\\\")\\n\\n if crvType == 2:\\n if len(pList) == 2:\\n f = [float(sum(x)/2) for x in zip(*pList)]\\n pList.insert(1, f)\\n crv = cmds.curve(d=3, ep=pList, name=\\\"newCurve\\\")\\n\\n return(crv)\",\n \"def __init__(\\n self, name: str, values: List[Dict], index: Optional[int] = 0,\\n label: Optional[str] = None, help: Optional[str] = None,\\n default: Optional[bool] = None, required: Optional[bool] = False,\\n group: Optional[str] = None\\n ):\\n super(Select, self).__init__(\\n dtype=PARA_SELECT,\\n name=name,\\n index=index,\\n label=label,\\n help=help,\\n default=default,\\n required=required,\\n group=group\\n )\\n self.values = values\",\n \"def build_selection_spec(client_factory, name):\\r\\n sel_spec = client_factory.create('ns0:SelectionSpec')\\r\\n sel_spec.name = name\\r\\n return sel_spec\",\n \"def __init__(self):\\n super().__init__()\\n self.n = 0.0\\n self.p = 0.0\\n self.type = 'Binomial'\\n self.hasInfiniteBound = True\\n self.distType = 'Discrete'\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def select(self):\\n\\t\\tbest_num_components = self.n_constant\\n\\t\\treturn self.base_model(best_num_components)\",\n \"def pdos_select(self, atoms=None, spin=None, l=None, m=None):\\n valid_m_values = {'s': [],\\n 'p': ['x', 'y', 'z'],\\n 'd': ['xy', 'yz', 'z2-r2', 'xz', 'x2-y2'],\\n 'f': ['y(3x2-y2)', 'xyz', 'yz2', 'z3', 'xz2', 'z(x2-y2)', 'x(x2-3y2)']}\\n if not atoms:\\n atom_idx = list(range(self.number_of_atoms))\\n else:\\n atom_idx = atoms\\n to_return = self.pdos_raw[atom_idx, :, :, :]\\n if not spin:\\n spin_idx = list(range(self.ispin))\\n elif spin == 'up':\\n spin_idx = [0]\\n elif spin == 'down':\\n spin_idx = [1]\\n elif spin == 'both':\\n spin_idx = [0, 1]\\n else:\\n raise ValueError\\n to_return = to_return[:, :, :, spin_idx]\\n\\n if not l:\\n channel_idx = list(range(self.number_of_channels))\\n elif l == 's':\\n channel_idx = [0]\\n elif l == 'p':\\n if not m:\\n channel_idx = [1, 2, 3]\\n else:\\n channel_idx = [1 + i for i, v in enumerate(valid_m_values['p']) if v in m]\\n elif l == 'd':\\n if not m:\\n channel_idx = [4, 5, 6, 7, 8]\\n else:\\n channel_idx = [4 + i for i, v in enumerate(valid_m_values['d']) if v in m]\\n elif l == 'f':\\n if not m:\\n channel_idx = [9, 10, 11, 12, 13, 14, 15]\\n else:\\n channel_idx = [9 + i for i, v in enumerate(valid_m_values['f']) if v in m]\\n else:\\n raise ValueError\\n\\n return to_return[:, :, channel_idx, :]\",\n \"def __init__(self, parent):\\n # parent is the main frame of PyCorrFit\\n self.parent = parent\\n ## MYID\\n # This ID is given by the parent for an instance of this class\\n self.MyID = None\\n ## Wrapping\\n curvedict, labels = self.GetCurvedict()\\n self.labels = labels\\n self.Selector = UserSelectCurves(parent, curvedict,\\n wrapper=self, labels=labels)\\n # This is necessary for parent to deselect and select the tool\\n # in the tools menu.\\n self.Bind = self.Selector.Bind\\n if self.parent.notebook.GetPageCount() == 0:\\n self.Selector.sp.Disable()\",\n \"def __init__(self, p) -> None:\\n self._p = p\\n self._delegate = TwoQubitAsymmetricDepolarizingChannel(p / 15, p / 15, p / 15,\\n p / 15, p / 15, p / 15,\\n p / 15, p / 15, p / 15,\\n p / 15, p / 15, p / 15,\\n p / 15, p / 15, p / 15)\",\n \"def _an_element_(self):\\n from sage.rings.integer_ring import ZZ\\n return self(self.realization_of().PD().get_point(ZZ.zero()))\",\n \"def 选择项目(self, n): # real signature unknown; restored from __doc__\\n return self.Select(n)\",\n \"def _select_single(self, disc):\\n return QuadraticFieldClassNumbersTable._select_single(self, -disc)\",\n \"def __init__(self, r=1, p=3):\\n self.p = p\\n self.r = r\",\n \"def generate_kdtree(self):\\n if self.method==2:\\n coordinates = self.unassigned_data[0:3,:]\\n else:\\n coordinates = self.unassigned_data[0:2,:]\\n tree = cKDTree(coordinates.T)\\n\\n return tree\",\n \"def make_selection(self, num):\\n other_doors = None\\n if num is 1:\\n other_doors = [str(2), str(3)]\\n elif num is 2:\\n other_doors = [str(1), str(3)]\\n elif num is 3:\\n other_doors = [str(1), str(2)]\\n\\n reveal = str(random.choice(other_doors))\\n other_doors.remove(reveal)\\n third_door = random.choice(other_doors)\\n other_doors.remove(third_door)\\n\\n main_door = getattr(self, 'door' + str(num) + '_counter')\\n door_second = getattr(self, 'door' + reveal + '_counter')\\n door_third = getattr(self, 'door' + third_door + '_counter')\\n main_door_reveal = getattr(self, 'door'+str(num)+'_reveal')\\n\\n if (main_door is 0 and door_second is 0\\n and door_third is 0):\\n self.ids['door'+reveal].source = \\\\\\n getattr(self, 'door'+reveal+'_reveal')\\n self.ids['button'+reveal].disabled = True\\n inc = getattr(self, 'door' + str(num) + '_counter')\\n setattr(self, 'door' + str(num) + '_counter', inc + 1)\\n elif main_door is 1 and door_second is 0 and door_third is 0:\\n for i in range(1, 4, 1):\\n self.ids['door' + str(i)].source = \\\\\\n getattr(self, 'door' + str(i) + '_reveal')\\n self.ids['button'+str(i)].disabled = True\\n if main_door_reveal in ['door-money.png']:\\n self.win_popup()\\n else:\\n self.lose_popup()\\n elif main_door is 0 and (door_second is 1 or door_third is 1):\\n for i in range(1, 4, 1):\\n self.ids['door' + str(i)].source = \\\\\\n getattr(self, 'door' + str(i) + '_reveal')\\n self.ids['button'+str(i)].disabled = True\\n if main_door_reveal in ['door-money.png']:\\n self.win_popup()\\n else:\\n self.lose_popup()\",\n \"def get_selection():\\n\\n selected = Gui.Selection.getSelectionEx()[0].SubObjects\\n sel_len = len(selected)\\n result = SelectionContainer()\\n\\n for _x in range(0, sel_len):\\n\\n shape_type = selected[_x].ShapeType\\n\\n if shape_type == 'Vertex':\\n result.vertices.append(selected[_x])\\n\\n elif shape_type == 'Edge':\\n\\n if 'Line' in str(selected[_x].Curve):\\n result.lines.append(selected[_x])\\n else:\\n result.curves.append(selected[_x])\",\n \"def __init__(self, disk_radius=None, even_sampling=False, no_data_value=None, ignore_labels=None):\\n self.disk_radius = disk_radius\\n self.ignore_labels = [] if ignore_labels is None else ignore_labels\\n self.even_sampling = even_sampling\\n self.no_data_value = no_data_value\",\n \"def initP0(self, size, radius):\\n return h.circle(size, radius)[:, :, 0]\",\n \"def selection(self):\\n # create an empty priority queue for the new generation\\n newGeneration = PriorityQueue()\\n # pick top X of the population to survive\\n for c in range(0, self.generation.qsize() / SELECTION_FRACTION):\\n # get a chromosome\\n chromosome = self.generation.get()\\n # put the chromosomes in the new generation\\n newGeneration.put(chromosome)\\n # keep the new generation\\n self.generation = newGeneration\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.PseudoDC_swiginit(self,_gdi_.new_PseudoDC(*args, **kwargs))\",\n \"def __init__(self,min_instances=30, drift_level=3.0):\\n\\n from math import sqrt\\n self.min_instances = min_instances\\n self.drift_level = float(drift_level)\\n self.i = None\\n self.pi = None\\n self.si = None\\n self.pi_min = None\\n self.si_min = None\\n self.sqrt=sqrt\\n self.reset()\",\n \"def __init__(self):\\n super().__init__()\\n self.mu = 0.0\\n self.type = 'Poisson'\\n self.hasInfiniteBound = True\\n self.distType = 'Discrete'\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def _create_example_door():\\n return Door({\\\"warning\\\": False, \\\"closed\\\": True, \\\"locked\\\": False})\",\n \"def construct_random_initial(self):\\n x = np.random.random((self._crv_size, self._bound))\\n return x\",\n \"def pool_selected( self, object ):\\n\\t\\tud.debug( ud.ADMIN, ud.INFO, 'UVMM.DW.ps(node_uri=%s)' % self.node_uri)\\n\\t\\tpool_name = object.options.get('pool-name')\\n\\t\\tif not pool_name:\\n\\t\\t\\tpool_name = object.options['pool-name'] = 'default'\\n\\t\\tdrive_type = object.options['drive-type']\\n\\t\\ttry:\\n\\t\\t\\tif drive_type == 'cdrom':\\n\\t\\t\\t\\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'cdrom')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tvols = self.uvmm.storage_pool_volumes(self.node_uri, pool_name, 'disk' )\\n\\t\\texcept uvmmd.UvmmError, e:\\n\\t\\t\\tvols = ()\\n\\t\\tud.debug(ud.ADMIN, ud.INFO, 'UVMM.DW.ps: volumes=%s' % map(str, vols))\\n\\t\\tchoices = []\\n\\t\\tfor vol in vols:\\n\\t\\t\\tbasename = os.path.basename( vol.source )\\n\\t\\t\\tif '.' in basename:\\n\\t\\t\\t\\tsuffix = basename[ basename.rfind( '.' ) + 1 : ]\\n\\t\\t\\t\\tif suffix in ( 'xml', 'snapshot' ):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\tchoices.append( basename )\\n\\t\\tchoices.sort()\\n\\t\\tself.image_syntax.update_choices( choices )\\n\\n\\t\\t# recreate pool button\\n\\t\\tbtn = self._create_pool_select_button( object.options )\\n\\t\\tself[DriveWizard.PAGE_OLD].options[0] = btn\\n\\t\\tself[DriveWizard.PAGE_NEW].options[0] = btn\\n\\t\\t# recreate driver-type button\\n\\t\\titems = [self[DriveWizard.PAGE_NEW].options[2].id(), self[DriveWizard.PAGE_NEW].options[3].id()]\\n\\t\\tbtn = self._create_type_select_button(object.options, items)\\n\\t\\tself[DriveWizard.PAGE_NEW].options[1] = btn\\n\\n\\t\\tif drive_type == 'disk':\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].hint = None\\n\\t\\telif drive_type in ( 'cdrom', 'floppy' ):\\n\\t\\t\\tif self.image_syntax._choices:\\n\\t\\t\\t\\tmsg = _( \\\"If the required image is not found it might be added by copying the file into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\\\" )\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmsg = _( \\\"The list of available images is empty! To add an image the file needs to be copied into the storage pool, e.g. to /var/lib/libvirt/images/ which is the directory of the storage pool <i>local directory</i>. After that go to the previous page and return to this one. The image should now be listed.\\\" )\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].hint = msg\\n\\t\\t\\tself[DriveWizard.PAGE_OLD].description = ''\\n\\t\\telse:\\n\\t\\t\\traise ValueError('Invalid drive-type \\\"%s\\\"' % drive_type)\\n\\n\\t\\treturn self.type_selected(object)\",\n \"def __make_slide(self):\\n # Create base rectangle for slide\\n length = self.parameters['slide_base_length'] + self.parameters['bearing_slide_travel']\\n width = self.parameters['slide_width']\\n height = self.parameters['slide_height']\\n slide = fso.Box(x=length,y=width,z=height)\\n # Create the mounting holes\\n radius = 0.5*self.parameters['slide_screw_size']\\n base_hole = fso.Cylinder(r=radius, l=2*height)\\n hole_list = []\\n for i in (-1,1):\\n for j in (-1,1):\\n xpos = i*(0.5*length - self.parameters['slide_screw_inset'])\\n ypos = j*(0.5*self.parameters['slide_screw_dW'])\\n hole = base_hole.copy()\\n hole.translate([xpos,ypos,0])\\n hole_list.append(hole)\\n # Remove hole material\\n slide -= hole_list\\n slide.set_color(self.slide_color,recursive=True)\\n self.slide = slide\",\n \"def __init__(self, r1=4.5*0.0254, r2=4.5*0.0254,\\n d1=25.0*0.0254, d2=25.0*0.0254,\\n Ixx=185000.0*0.45359237*0.0254**2,\\n Iyy=185000.0*0.45359237*0.0254**2,\\n Izz=3500.0*0.45359237*0.0254**2,):\\n self.r1 = r1 # m\\n self.r2 = r2 # m\\n self.d1 = d1 # m\\n self.d2 = d2 # m\\n self.Ixx = Ixx # kg-m^2\\n self.Iyy = Iyy # kg-m^2\\n self.Izz = Izz # kg-m^2\",\n \"def selection(self):\\n if not self._selection:\\n return None\\n \\n year, month = self._date.year, self._date.month\\n return self.datetime(year, month, int(self._selection[0]))\",\n \"def _generate_solution(self):\\n \\n operation_list = []\\n available = {job.get_job_id(): [operation for operation in job.get_operations() if operation.get_sequence() == 0] for job in self.jssp_instance_data.jobs} # dictionary of first unprocessed operations of each job\\n \\n while 0 < len(available):\\n rand_job_id = random.choice(list(available.keys()))\\n rand_operation = random.choice(available[rand_job_id])\\n rand_machine = np.random.choice(rand_operation.get_required_machines())\\n\\n available[rand_job_id].remove(rand_operation)\\n \\n if len(available[rand_job_id]) == 0:\\n # if selected operation is last operation of the job \\n if rand_operation.get_sequence() == self.jssp_instance_data.get_job(rand_job_id).get_max_sequence():\\n del available[rand_job_id]\\n else:\\n available[rand_job_id] = [t for t in self.jssp_instance_data.get_job(rand_job_id).get_operations() if\\n t.get_sequence() == rand_operation.get_sequence() + 1]\\n\\n\\n operation_list.append([rand_job_id, rand_operation.get_operation_id(), rand_operation.get_sequence(), rand_machine]) # chromosome representation \\n return Solution(self.jssp_instance_data, np.array(operation_list, dtype=np.intc))\",\n \"def __init__(self, dict = {}):\\r\\n if dict == {}:\\r\\n self.zero_val()\\r\\n else:\\r\\n self.piDD = dict\\r\\n self.top_node = utilities.max_length_in_list(self.return_keys())\\r\\n if self.piDD[self.top_node] == None:\\r\\n self.dim = 0\\r\\n else:\\r\\n self.dim = self.piDD[self.top_node][0][0]\",\n \"def __init__(self):\\n\\n self.P = list()\\n self.label = 0\",\n \"def __init__(self, radius=0.5, extra={}):\\n self.radius = radius\\n self.sensors = [] # array of Attached\\n self.id_sensors = None\\n self.id_dynamics = None # XXX\\n self.dynamics = None\\n self.extra = extra\\n\\n self.primitives = set()\\n\\n # Needs to be initialized before calling certain functions\\n self._state = None\",\n \"def __init__(self):\\n raise NotImplementedError('cannot create independent arc')\",\n \"def eta23pi ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import DaVinci__N3BodyDecays\\n ## \\n pre_eta = self.make_selection (\\n ## the unique tag \\n 'PreEta3Pi' ,\\n ## algorithm type to be used\\n DaVinci__N3BodyDecays ,\\n ## input selections \\n [ self.pions () , self.pi0 () ] ,\\n ## algorithm properties \\n DecayDescriptor = \\\" eta -> pi+ pi- pi0\\\" ,\\n ## \\n Combination12Cut = \\\"\\\"\\\" ( AM < 700 * MeV ) &\\n ( ACHI2DOCA(1,2) < 12 ) \\n \\\"\\\"\\\" , \\n ##\\n CombinationCut = \\\"\\\"\\\"\\n ( APT > %s ) & ( ADAMASS ( 'eta' ) < 100 * MeV )\\n \\\"\\\"\\\" % ( 0.9 * self['ETA_PT'] ) ,\\n ##\\n MotherCut = \\\"\\\"\\\"\\n ( PT > %s ) &\\n ( chi2vx < 9 ) \\n \\\"\\\"\\\" % self['ETA_PT']\\n )\\n ##\\n from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger2g\\n ## \\n return self.make_selection (\\n 'Eta23pi' ,\\n Pi0Veto__Tagger2g ,\\n [ pre_eta ] ,\\n MassWindow = 25 * MeV ,\\n MassChi2 = -1 ,\\n ExtraInfoIndex = 25016 ## unique ! \\n )\",\n \"def _select(self):\\n sel = []\\n\\n # choose randomly while favouring fit individuals\\n lp = len(self.population) // 2\\n for _ in range(lp):\\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n while idx1 == idx2:\\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n\\n p1, p2 = self.population[idx1], self.population[idx2]\\n sel.append((p1, p2))\\n\\n return sel\",\n \"def __init__(self, d):\\n\\t\\tself._coords = [0] * d\",\n \"def test_non_it(self):\\n self.idx = [9, 11, 6, 10, 12, 2, 8, 1, 5, 0, 7, 4, 3]\\n selector = PCovCUR(n_to_select=12, iterative=False)\\n selector.fit(self.X, self.y)\\n\\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))\",\n \"def __init__(self):\\n\\n # Assign a nullptr for the device-side pointers. These will be set if the GPU is utilized.\\n self.ng = int(0)\\n self.goals = ct.POINTER(ct.c_uint)()\\n self.currentHorizon = int(0)\\n self.V = ct.POINTER(ct.c_float)()\\n self.VPrime = ct.POINTER(ct.c_float)()\\n self.pi = ct.POINTER(ct.c_uint)()\\n self.ne = int(0)\\n self.expanded = ct.POINTER(ct.c_int)()\\n self.d_goals = ct.POINTER(ct.c_uint)()\\n self.d_S = ct.POINTER(ct.c_int)()\\n self.d_T = ct.POINTER(ct.c_float)()\\n self.d_R = ct.POINTER(ct.c_float)()\\n self.d_V = ct.POINTER(ct.c_float)()\\n self.d_VPrime = ct.POINTER(ct.c_float)()\\n self.d_pi = ct.POINTER(ct.c_uint)()\\n self.d_expanded = ct.POINTER(ct.c_int)()\\n\\n # Additional informative variables.\\n self.Rmin = None\\n self.Rmax = None\",\n \"def selected_choice(self):\\r\\n choice = zeros(self.num_agents)\\r\\n random_numbers = self.generate_random_numbers()\\r\\n\\r\\n self.prob_cumsum = self.cumprob().filled(-1)\\r\\n\\r\\n for i in range(self.num_choices):\\r\\n # Indicator for the zero cells in the choice array\\r\\n #indicator_zero_cells = ones(self.num_agents)\\r\\n indicator = array([True]*self.num_agents)\\r\\n\\r\\n zero_indices = choice == 0\\r\\n #indicator_zero_cells[~zero_indices] = ma.masked\\r\\n indicator[~zero_indices] = False\\r\\n\\r\\n # Indicator for the cells where the random number\\r\\n # is less than the probability\\r\\n #indicator_less_cells = ones(self.num_agents)\\r\\n #indicator_less_cells = array([True]*self.num_agents)\\r\\n less_indices = random_numbers < self.prob_cumsum[:,i]\\r\\n #indicator_less_cells[~less_indices] = ma.masked\\r\\n #indicator_less_cells\\r\\n indicator[~less_indices] = False\\r\\n\\r\\n\\r\\n #indicator_less_zero_cells = indicator_zero_cells + indicator_less_cells\\r\\n\\r\\n #indicator_less_zero_cells = indicator_less_zero_cells == 2\\r\\n\\r\\n choice[indicator] = i + 1\\r\\n\\r\\n choice.shape = (self.num_agents, 1)\\r\\n\\r\\n #alt_text = []\\r\\n #for i in choice:\\r\\n # alt_text.append(self.choices[int(i[0])-1])\\r\\n #alt_text = array(alt_text)\\r\\n #alt_text.shape = (self.num_agents, 1)\\r\\n\\r\\n #return alt_text\\r\\n #print choice\\r\\n return DataArray(choice, ['selected choice'])\",\n \"def __init__(self, analogue_selection='indep', clock_selection='in', cal_mode='no_cal', clk_speed=800):\\n self.value = 0\\n self.value |= (0b1 << 2) # disable chip version output bit\\n self.value |= (0b1 << 3) # set demux to 1:2\\n clk_bits = 0b00 if (clk_speed<125) else 0b01 if (clk_speed<250) else 0b10 if (clk_speed<500) else 0b11\\n self.value |= (clk_bits << 12) # control wait bit calibration value is dependent on clk speed\\n self.value |= (1 << 14) # set FDataReady to Fs/2. I don't know what this means\\n self.set_analogue_selection(analogue_selection)\\n self.set_clock_selection(clock_selection)\\n self.set_cal_mode(cal_mode)\",\n \"def pi(self):\\n return self(self._real_field().pi())\",\n \"def __init__(self):\\n super().__init__()\\n self.lambdaVar = 1.0\\n self.low = 0.0\\n self.type = 'Exponential'\\n self.distType = 'Continuous'\\n self.hasInfiniteBound = True\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def __init__(self, params):\\r\\n _params = {'Similarity': 0.97,\\r\\n 'Application': 'cdhit',\\r\\n 'Algorithm': 'cdhit: \\\"longest-sequence-first list removal algorithm\\\"'}\\r\\n _params.update(params)\\r\\n OtuPicker.__init__(self, _params)\",\n \"def __init__(self, goal=0, kP=1, kI=1, kD=1, init_pt=0):\\n self._pid_lock = threading.Lock()\\n\\n self.set_goal(goal)\\n self.reset(init_pt)\\n self.set_gains({\\n PIDController.KP_KEY: kP,\\n PIDController.KI_KEY: kI,\\n PIDController.KD_KEY: kD\\n })\",\n \"def __init__(\\n self, voltage={0:(0, 0)}, rate=500, repetitions=1,\\n board_name='cDAQ1Mod1', voltage_limits=None, num_channels=7):\\n self.board_name = board_name #Check Measurement and Automation Explorer\\n self._taskHandle = ctypes.c_void_p(0)\\n self.num_channels = num_channels\\n DAQmxErrChk(api.DAQmxCreateTask(\\\"\\\", ctypes.byref(self._taskHandle)))\\n DAQmxErrChk(api.DAQmxCreateAOVoltageChan(\\n self._taskHandle,\\n self.board_name + \\\"/ao0:%i\\\"%(num_channels - 1),\\n \\\"\\\",\\n ctypes.c_double(-10.0), #Minimum voltage\\n ctypes.c_double(10.0), #Maximum voltage\\n 10348, #DAQmx_Val_Volts; don't question it!\\n ctypes.c_void_p(0), #NULL\\n ))\\n self.num_points_written = ctypes.c_long(0)\\n self._unwritten_voltages = False\\n self._unplayed_voltages = False\\n self.set_voltage_and_timing(voltage, rate, repetitions, voltage_limits)\\n return None\",\n \"def select(self):\\n\\n return self.p[0], self.p[1]\",\n \"def null(cls, d=2):\\n return cls(*[0 for i in range(d)])\",\n \"def get_selection(self, selection_name, format=None):\",\n \"def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\\n self.GP = GPIOProcessor()\\n self.pin1 = self.GP.getPin(pin1)\\n self.pin2 = self.GP.getPin(pin2)\\n self.pin3 = self.GP.getPin(pin3)\\n self.pin4 = self.GP.getPin(pin4)\\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\\n\\n for k in range(4):\\n self.pinl[k].out()\\n\\n self.speed = 100.0\",\n \"def circle(self):\\n return circle(self.N, self.o, self.r)\",\n \"def p_selection(p_init, it, n_iters):\\n it = int(it / n_iters * 10000)\\n\\n if 10 < it <= 50:\\n p = p_init / 2\\n elif 50 < it <= 200:\\n p = p_init / 4\\n elif 200 < it <= 500:\\n p = p_init / 8\\n elif 500 < it <= 1000:\\n p = p_init / 16\\n elif 1000 < it <= 2000:\\n p = p_init / 32\\n elif 2000 < it <= 4000:\\n p = p_init / 64\\n elif 4000 < it <= 6000:\\n p = p_init / 128\\n elif 6000 < it <= 8000:\\n p = p_init / 256\\n elif 8000 < it <= 10000:\\n p = p_init / 512\\n else:\\n p = p_init\\n\\n return p\",\n \"def select_arm(self):\\n\\n # Exploitation\\n if random.uniform(0, 1) > self.epsilon:\\n return np.argmax(self.values)\\n\\n # Exploration\\n else:\\n return random.randrange(len(self.values))\",\n \"def pick(self):\\n\\n pickerdict = {}\\n current_value = 0\\n\\n if len(self.choices) == 0:\\n return None\\n\\n if len(self.choices) == 1:\\n return self.choices[0][0]\\n\\n for option in self.choices:\\n pickerdict[current_value] = option[0]\\n current_value += option[1]\\n\\n picker = random.randint(0, current_value)\\n last_value = 0\\n result = None\\n sorted_keys = sorted(pickerdict.keys())\\n\\n found = False\\n for key in sorted_keys:\\n if key >= picker:\\n result = pickerdict[last_value]\\n found = True\\n continue\\n last_value = key\\n\\n if not found:\\n result = pickerdict[sorted_keys[-1]]\\n\\n return result\",\n \"def select(self):\\n pass\",\n \"def select(self):\\n pass\",\n \"def __init__(self, choice):\\r\\n self.choice = choice\",\n \"def make_car():\\n car = Car() \\n car.drop_val = random.randint(0,1)\\n\\n if car.drop_val == 0:\\n car.drop_x = random.randint(77, 400) * 2\\n\\n elif car.drop_val == 1:\\n car.drop_y = random.randint(62, 300) *2\\n\\n return car\",\n \"def __init__(self, D, K):\\n\\t\\tself.D = D \\n\\t\\tself.K = K \\n\\t\\tself.V = np.zeros((D+1,K))\\n\\t\\treturn\",\n \"def dropdown(self):\\n # defaults = DDConfig(0.6, 0.6, 0, 0)\\n return DropDown(self.name, self.command, **self.config)\",\n \"def __init__(self, inplace=False):\\n super(SELU, self).__init__()\\n self.inplace = inplace\",\n \"def __init__(self, motor, OD_range=None, motor_range=None,\\n motor_min=None, OD_min=None, motor_max=None, OD_max=None):\\n self.motor = motor\\n if OD_range is not None:\\n self.OD_range = OD_range\\n if motor_range is not None:\\n self.motor_range = motor_range\\n\\n if motor_min is not None:\\n self.motor_min = motor_min\\n else:\\n self.motor_min = motor_range[0]\\n\\n if motor_max is not None:\\n self.motor_max = motor_max\\n else:\\n self.motor_max = motor_range[1]\\n\\n if OD_min is not None:\\n self.OD_min = OD_min\\n else:\\n self.OD_min = OD_range[0]\\n\\n if OD_max is not None:\\n self.OD_max = OD_max\\n else:\\n self.OD_max = OD_range[1]\",\n \"def touching_choice(self,p):\\n\\n part = ['head', 'foot1', 'foot2', 'foot3', 'foot4', 'back', 'stomach', 'tail']\\n if len(self.select[p]) == 0:\\n return random.sample(part,2)\\n elif len(self.select[p]) == 1:\\n part.remove(self.select[p][0])\\n c = random.sample(part,1)\\n return [self.select[p][0], c[0]]\\n else:\\n return random.sample(self.select[p],2)\",\n \"def select(self):\\r\\n pass\",\n \"def __init__(self, r: float, i: float = 0):\\n self.r = r\\n self.i = i\",\n \"def __init__(self, tpose, mpose, tselect=[], mselect=[]):\\n self.target = tpose\\n self.mobile = mpose\\n self.target_residues = res_selector_to_size_list(tselect)\\n self.mobile_residues = res_selector_to_size_list(mselect)\\n self.set_target_sequence()\\n self.set_mobile_sequence()\\n self.atoms = ['N','C','CA']\\n self.bb_rmsd = None\",\n \"def create_soft_cluster():\\n # node, index_component, inf_val = general.get_soft_selection()\\n soft_element_data = general.get_soft_selection()\\n selection = [vtx_component for vtx_component, inf_val in soft_element_data]\\n\\n pm.select(selection, r=True)\\n cluster = pm.cluster(relative=True)\\n\\n for vtx_component, inf_val in soft_element_data:\\n pm.percent(cluster[0], vtx_component, v=inf_val)\\n pm.select(cluster[1], r=True)\\n\\n return cluster\",\n \"def __init__(self):\\n {}\\n #generate a monoid Q\\n self.monoid_Q = self.generateQ()[0]\\n self.relationOfElements_Q = self.generateQ()[1]\\n self.p_Position = self.generateQ()[2]\\n self.qOfPosition = self.generateQ()[3]\\n #print(self.qOfPosition)\",\n \"def zero_val(self):\\r\\n self.piDD = {\\\"[0]\\\": None}\\r\\n self.top_node = \\\"[0]\\\"\\r\\n self.dim = 0\",\n \"def get_slider():\\n return dcc.RangeSlider(\\n id='hours',\\n value=[0, 23],\\n min=0,\\n max=23,\\n marks={i: str(i) for i in range(0, 24, 3)}\\n )\",\n \"def choose_pos(self):\\n s = self\\n\\n availablepos = []\\n for dblock in s.pjs.dblocks:\\n is_available = True\\n\\n for powerup in s.pjs.powerups:\\n if powerup.rects[0].overlap(dblock.rects[0]):\\n is_available = False\\n break\\n\\n if is_available:\\n availablepos.append(dblock.rpos)\\n\\n pos = random.randint(0, len(availablepos) - 1)\\n s.rpos = availablepos[pos]\",\n \"def __init__(self):\\n super().__init__()\\n self.low = 0.0\\n self.high = 1.0\\n self.alpha = 0.0\\n self.beta = 0.0\\n self.type = 'Beta'\\n self.distType = 'Continuous'\\n self.hasInfiniteBound = True\\n self.compatibleQuadrature.append('Jacobi')\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'Jacobi'\\n self.preferredPolynomials = 'Jacobi'\",\n \"def selectPointsUnderCursor(self):\\n spw = self.spw\\n sw = spw.windows['Sort']\\n #if clear:\\n # sw.uslist.clearSelection()\\n # sw.nlist.clearSelection()\\n x, y = self.cursorPosGL()\\n sids = self.pick(x, y, pb=10, multiple=True)\\n if sids is None:\\n return\\n #t0 = time.time()\\n spw.SelectSpikes(sids, on=self.selecting)\\n #print('SelectSpikes took %.3f sec' % (time.time()-t0))\\n if self.selecting == True:\\n sat = 0.2 # desaturate\\n else: # self.selecting == False\\n sat = 1 # resaturate\\n self.color(sids, sat=sat)\\n self.updateGL()\",\n \"def selection(self) -> Chromosome:\\n # each chromosome has a fitness, and the lower the fitness, the higher the probability of election\\n choices_list = list(range(len(self._population)))\\n weights = [1 / chromosome.get_fitness() for chromosome in self._population]\\n\\n index = choices(choices_list, weights=weights)[0]\\n\\n return self._population[index]\",\n \"def create_pressure_vessel_geometry():\\r\\n\\r\\n # configure sigmoid function\\r\\n bounds_upper = [3, 6]\\r\\n h = 5\\r\\n w = 6\\r\\n\\r\\n sigmoid_function = lambda x: (1 / (1 + np.exp(-1 * h * x + w))) + 1\\r\\n\\r\\n sigmoid_function_reverse = lambda x: 1 / (1 + np.exp(h * x - w - 18)) + 1\\r\\n\\r\\n funcs_upper = [sigmoid_function, sigmoid_function_reverse]\\r\\n\\r\\n bounds_lower = None\\r\\n funcs_lower = 0\\r\\n\\r\\n x_max = 6\\r\\n x_min = 0\\r\\n resolution = 10000\\r\\n\\r\\n pressure_vessel = Geometry(x_max, x_min, resolution,\\r\\n bounds_upper, funcs_upper,\\r\\n bounds_lower, funcs_lower)\\r\\n\\r\\n return pressure_vessel\",\n \"def random(cls, d=2, borns=[-1, 1], **kwargs):\\n components = [random.uniform(*borns) for i in range(d)]\\n return cls(*components, **kwargs)\",\n \"def random(cls, d=2, borns=[-1, 1], **kwargs):\\n components = [random.uniform(*borns) for i in range(d)]\\n return cls(*components, **kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65183586","0.6036616","0.58945334","0.55806303","0.5347493","0.53058124","0.5261733","0.51529664","0.50806415","0.5059661","0.50538725","0.50354403","0.5012788","0.4933138","0.49302754","0.48780695","0.48642525","0.4854433","0.4833495","0.48240137","0.4793768","0.47933662","0.478876","0.47886172","0.47840276","0.47784555","0.47292686","0.47277686","0.47275457","0.4723399","0.47140983","0.46943375","0.4684248","0.4681723","0.46263233","0.46263233","0.46263233","0.46263233","0.46263233","0.46263233","0.46263233","0.46263233","0.46263233","0.46227065","0.46197912","0.4606822","0.46054325","0.46035653","0.4589436","0.45894","0.45707285","0.45663157","0.45569476","0.45543933","0.45372185","0.4531875","0.45277584","0.45277193","0.4526098","0.45167056","0.45129544","0.45127553","0.44958597","0.449459","0.44927624","0.44874167","0.44785053","0.447828","0.44742787","0.44716415","0.4465707","0.44648972","0.44614938","0.44611254","0.44586134","0.44572446","0.44523677","0.44516554","0.44516554","0.44455868","0.44427782","0.4439188","0.4433058","0.44299138","0.44277158","0.44272554","0.44166902","0.4415884","0.44089264","0.44023633","0.43929407","0.43907556","0.43897092","0.43888915","0.43872088","0.43813017","0.4378417","0.43783","0.43780282","0.43780282"],"string":"[\n \"0.65183586\",\n \"0.6036616\",\n \"0.58945334\",\n \"0.55806303\",\n \"0.5347493\",\n \"0.53058124\",\n \"0.5261733\",\n \"0.51529664\",\n \"0.50806415\",\n \"0.5059661\",\n \"0.50538725\",\n \"0.50354403\",\n \"0.5012788\",\n \"0.4933138\",\n \"0.49302754\",\n \"0.48780695\",\n \"0.48642525\",\n \"0.4854433\",\n \"0.4833495\",\n \"0.48240137\",\n \"0.4793768\",\n \"0.47933662\",\n \"0.478876\",\n \"0.47886172\",\n \"0.47840276\",\n \"0.47784555\",\n \"0.47292686\",\n \"0.47277686\",\n \"0.47275457\",\n \"0.4723399\",\n \"0.47140983\",\n \"0.46943375\",\n \"0.4684248\",\n \"0.4681723\",\n \"0.46263233\",\n \"0.46263233\",\n \"0.46263233\",\n \"0.46263233\",\n \"0.46263233\",\n \"0.46263233\",\n \"0.46263233\",\n \"0.46263233\",\n \"0.46263233\",\n \"0.46227065\",\n \"0.46197912\",\n \"0.4606822\",\n \"0.46054325\",\n \"0.46035653\",\n \"0.4589436\",\n \"0.45894\",\n \"0.45707285\",\n \"0.45663157\",\n \"0.45569476\",\n \"0.45543933\",\n \"0.45372185\",\n \"0.4531875\",\n \"0.45277584\",\n \"0.45277193\",\n \"0.4526098\",\n \"0.45167056\",\n \"0.45129544\",\n \"0.45127553\",\n \"0.44958597\",\n \"0.449459\",\n \"0.44927624\",\n \"0.44874167\",\n \"0.44785053\",\n \"0.447828\",\n \"0.44742787\",\n \"0.44716415\",\n \"0.4465707\",\n \"0.44648972\",\n \"0.44614938\",\n \"0.44611254\",\n \"0.44586134\",\n \"0.44572446\",\n \"0.44523677\",\n \"0.44516554\",\n \"0.44516554\",\n \"0.44455868\",\n \"0.44427782\",\n \"0.4439188\",\n \"0.4433058\",\n \"0.44299138\",\n \"0.44277158\",\n \"0.44272554\",\n \"0.44166902\",\n \"0.4415884\",\n \"0.44089264\",\n \"0.44023633\",\n \"0.43929407\",\n \"0.43907556\",\n \"0.43897092\",\n \"0.43888915\",\n \"0.43872088\",\n \"0.43813017\",\n \"0.4378417\",\n \"0.43783\",\n \"0.43780282\",\n \"0.43780282\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5167268"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":7397,"cells":{"query":{"kind":"string","value":"dataloader for training dataset via voxsampler."},"document":{"kind":"string","value":"def load_train(trainlst, traindir, maptrain5994, L=L,\n batch_size=batch_size, num_worker=num_worker,\n max_utt_per_spk=max_utt_per_spk, load_wav=None):\n if load_wav is None:\n def load_train_wav(path): return loadWAV(path, L=L, evalmode=False)\n else:\n load_train_wav = load_wav\n df_train = pd.read_csv(trainlst, sep=\" \", header=None,\n names=[\"speaker\", \"file\"])\n df_train[\"file\"] = df_train[\"file\"].apply(lambda x: traindir + x)\n map_train = dict(pd.read_csv(maptrain5994, header=None).values)\n data = voxceleb2(df_train.values, map_train, load_train_wav)\n sampler = voxsampler(df_train, map_train,\n max_utt_per_spk=max_utt_per_spk, batch_size=batch_size)\n dataloader = DataLoader(data, batch_size=batch_size,\n num_workers=num_worker, shuffle=False,\n sampler=sampler)\n return dataloader"},"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 train_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)","def dataloader(self):\n\n # load / split data\n train_data = self.data.get_train_data()\n if self.args.use_dev:\n train_data, dev_data = self.data.split_data(train_data)\n test_data = self.data.get_test_data()\n\n #print(train_data[0])\n #print(dev_data[0])\n #print(test_data[0])\n\n # build dataset\n train_dataset = self.loader.build_dataset(\n train_data, \n self.args.train_max_seq_len)\n train_loader = self.loader.build_dataloader(\n train_dataset, 'train')\n\n test_dataset = self.loader.build_dataset(\n test_data,\n self.args.eval_max_seq_len)\n test_loader = self.loader.build_dataloader(\n test_dataset, 'test')\n\n if self.args.use_dev:\n dev_dataset = self.loader.build_dataset(\n dev_data,\n self.args.eval_max_seq_len)\n dev_loader = self.loader.build_dataloader(\n dev_dataset, 'dev')\n return train_loader, dev_loader, test_loader\n else:\n return train_loader, test_loader","def test_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_test, **self.dl_kwargs)","def train_dataloader(self) -> DataLoader:\n return self._custom_data_loader()","def train_dataloader(self):\r\n\r\n # transformation\r\n train_transform = Compose(\r\n [\r\n ApplyTransformToKey(\r\n key='video',\r\n transform=Compose(\r\n [\r\n UniformTemporalSubsample(8),\r\n Lambda(lambda x: x / 255.0),\r\n Normalize((0.45, 0.45, 0.45), (0.225, 0.225, 0.225)),\r\n RandomShortSideScale(min_size=256, max_size=320),\r\n RandomCrop(244),\r\n RandomHorizontalFlip(p=0.5),\r\n ]\r\n )\r\n )\r\n ]\r\n )\r\n\r\n train_dataset = pv.data.Kinetics(\r\n data_path=os.path.join(self._DATA_PATH, \"train\"),\r\n clip_sampler=pv.data.make_clip_sampler(\"random\", self._CLIP_DURATION),\r\n decode_audio=False,\r\n transform=train_transform\r\n )\r\n return torch.utils.data.DataLoader(\r\n train_dataset,\r\n batch_size=self._BATCH_SIZE,\r\n num_workers=self._NUM_WORKERS,\r\n )","def train_dataloader(self) -> DataLoader:\n return DataLoader(\n self.train_dataset,\n batch_size=self.hparams.batch_size,\n shuffle=True,\n num_workers=multiprocessing.cpu_count(),\n )","def val_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_valid, **self.dl_kwargs)","def create_dataloader(data):\r\n input_ids = torch.LongTensor([sent['input_ids'] for sent in data])\r\n input_mask = torch.LongTensor([sent['input_mask'] for sent in data])\r\n segment_ids = torch.LongTensor([sent['segment_ids'] for sent in data])\r\n label_ids = torch.LongTensor([sent['label_ids'] for sent in data])\r\n\r\n dataset = TensorDataset(input_ids, input_mask, segment_ids, label_ids)\r\n\r\n train_sampler = RandomSampler(dataset)\r\n dataloader = DataLoader(dataset, sampler=train_sampler, batch_size=BATCH_SIZE)\r\n\r\n return dataloader","def dataloader(self):\n return DataLoader","def dataloader_vatexEnglish_train(args, tokenizer):\n\n vatexEnglish_dataset = VATEXENGLISH_multi_sentence_dataLoader(\n subset=\"train\",\n data_path=args.data_path,\n features_path=args.features_path,\n max_words=args.max_words,\n feature_framerate=args.feature_framerate,\n tokenizer=tokenizer,\n max_frames=args.max_frames,\n )\n\n train_sampler = torch.utils.data.distributed.DistributedSampler(vatexEnglish_dataset)\n\n dataloader = DataLoader(\n vatexEnglish_dataset,\n batch_size=args.batch_size // args.n_gpu,\n num_workers=args.num_thread_reader,\n pin_memory=False,\n shuffle=(train_sampler is None),\n sampler=train_sampler,\n drop_last=True,\n )\n\n return dataloader, len(vatexEnglish_dataset), train_sampler","def _get_dataloader(samples, batch_size):\n print(\"Cogiendo dataloader\")\n return DataLoader(samples, shuffle=True, batch_size=batch_size)","def test_dataloader(self) -> data.DataLoader:\n return data.DataLoader(dataset=self.datasets['test'], batch_size=self.batch_size,\n num_workers=self.num_workers, shuffle=False, pin_memory=False)","def create_train_dataloader(configs):\n train_lidar_aug = OneOf([\n Random_Rotation(limit_angle=np.pi / 4, p=1.0),\n Random_Scaling(scaling_range=(0.95, 1.05), p=1.0),\n ], p=0.66)\n train_dataset = KittiDataset(configs, mode='train', lidar_aug=train_lidar_aug, hflip_prob=configs.hflip_prob,\n num_samples=configs.num_samples)\n train_sampler = None\n if configs.distributed:\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)\n train_dataloader = DataLoader(train_dataset, batch_size=configs.batch_size, shuffle=(train_sampler is None),\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=train_sampler)\n\n return train_dataloader, train_sampler","def _init_train_loader(self):\n # Choose the right dataset type\n if self.config_args[\"num_members\"] > 1:\n class_dataset_wrapper = dataset_wrapper.MixMoDataset\n else:\n class_dataset_wrapper = dataset_wrapper.MSDADataset\n\n # Load augmentations\n self.traindatasetwrapper = class_dataset_wrapper(\n dataset=self.train_dataset,\n num_classes=int(self.config_args[\"data\"][\"num_classes\"]),\n num_members=self.config_args[\"num_members\"],\n dict_config=self.config_args[\"training\"][\"dataset_wrapper\"],\n properties=self.properties\n )\n\n # Build standard sampler\n _train_sampler = torch.utils.data.sampler.RandomSampler(\n data_source=self.traindatasetwrapper, ## only needed for its length\n num_samples=None,\n replacement=False,\n )\n\n # Wrap it with the repeating sampler used for multi-input models\n batch_sampler = batch_repetition_sampler.BatchRepetitionSampler(\n sampler=_train_sampler,\n batch_size=self.batch_size,\n num_members=self.config_args[\"num_members\"],\n drop_last=True,\n config_batch_sampler=self.config_args[\"training\"][\"batch_sampler\"]\n )\n\n self.train_loader = torch.utils.data.DataLoader(\n self.traindatasetwrapper,\n batch_sampler=batch_sampler,\n num_workers=self.num_workers,\n batch_size=1,\n shuffle=False,\n sampler=None,\n drop_last=False,\n pin_memory=True,\n )","def prepare_dataloader(opt, dataobj):\n\n def load_data(name):\n with open(name, 'rb') as f:\n data = pickle.load(f)\n num_types = 1 # There is no event type prediction, hence using a dummy value, this will basically be a constant value field\n return data, num_types\n\n print('[Info] Loading train data...')\n train_data, num_types = load_data(opt.data + 'train_ny.pkl')\n print('[Info] Loading dev data...')\n val_data, _ = load_data(opt.data + 'val_ny.pkl')\n print('[Info] Loading test data...')\n test_data, _ = load_data(opt.data + 'test_ny.pkl')\n\n trainloader = get_dataloader(train_data, opt.batch_size, shuffle=True)\n validationloader = get_dataloader(val_data, opt.batch_size, shuffle=True)\n testloader = get_dataloader(test_data, opt.batch_size, shuffle=False)\n return trainloader, validationloader, testloader, num_types","def dataloader_msvd_train(args, tokenizer):\n\n msvd_dataset = MSVD_multi_sentence_dataLoader(\n subset=\"train\",\n data_path=args.data_path,\n features_path=args.features_path,\n max_words=args.max_words,\n feature_framerate=args.feature_framerate,\n tokenizer=tokenizer,\n max_frames=args.max_frames,\n )\n\n train_sampler = torch.utils.data.distributed.DistributedSampler(msvd_dataset)\n\n dataloader = DataLoader(\n msvd_dataset,\n batch_size=args.batch_size // args.n_gpu,\n num_workers=args.num_thread_reader,\n pin_memory=False,\n shuffle=(train_sampler is None),\n sampler=train_sampler,\n drop_last=True,\n )\n\n return dataloader, len(msvd_dataset), train_sampler","def test_dataloader(self) -> DataLoader:\n return DataLoader(\n self.test_dataset,\n batch_size=self.hparams.batch_size,\n shuffle=False,\n num_workers=multiprocessing.cpu_count(),\n )","def build_dataloader(bs, shfle):\n # change get_labels to correct version (classification vs regression)\n dataset = TensorDataset(rand_data(), get_labels())\n dataset = TensorDataset(rand_data(), get_regression_labels())\n\n return DataLoader(dataset, batch_size=bs, shuffle=shfle, num_workers=0)","def data_loader(data, train=True):\n\n loader_config = {\n 'batch_size':64,\n 'shuffle':train\n }\n \n return torch.utils.data.DataLoader(data, **loader_config)","def get_dataloaders(logging, batch_size):\n # Load Data\n logging.info(\"Reading Train and Test data...\")\n train_df = pd.read_csv(\"C:/tmp/avila_classification/data/avila-tr.txt\", header=None)\n test_df = pd.read_csv(\"C:/tmp/avila_classification/data/avila-ts.txt\", header=None)\n\n # Fix column names\n col_names = ['col_' + str(j + 1) for j in range(train_df.shape[1] - 1)]\n indep_cols = col_names.copy()\n col_names.append('y')\n\n logging.debug(\"Assigning columns\")\n train_df.columns = col_names\n test_df.columns = col_names\n\n # Encode dependent variable column\n le = LabelEncoder()\n le.fit(train_df['y'])\n logging.debug(f\"Classes: {le.classes_}\")\n logging.debug(f\"Transformed Classes: {le.transform(le.classes_)}\")\n\n train_df['y_enc'] = le.transform(train_df['y'])\n test_df['y_enc'] = le.transform(test_df['y'])\n\n # train_df.head()\n logging.debug(f\"Shape of train data: {train_df.shape}\")\n logging.debug(f\"Shape of test data: {test_df.shape}\")\n\n # Create train and validation dataloaders\n train_ds = AvilaDataset(data_frame=train_df, indep_cols=indep_cols, dep_col='y_enc')\n valid_ds = AvilaDataset(data_frame=test_df, indep_cols=indep_cols, dep_col='y_enc')\n\n # Should be some exponent of 2 (128, 256)\n # batch_size = 256\n train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n valid_dl = DataLoader(valid_ds, batch_size=batch_size, shuffle=False)\n\n return train_dl, valid_dl, le","def train_dataloader(self) -> data.DataLoader:\n # Random weighted sampler to approach the imbalanced dataset\n self.weights = [1.0 / i for i in self.weights]\n\n _sample_weights = [0] * len(self.datasets['train'])\n\n for idx, (_, label) in enumerate(self.datasets['train']):\n _weight = self.weights[label]\n _sample_weights[idx] = _weight\n\n random_sampler = data.WeightedRandomSampler(_sample_weights,\n len(self.datasets['train']), replacement=False)\n\n return data.DataLoader(dataset=self.datasets['train'], batch_size=self.batch_size,\n num_workers=self.num_workers, pin_memory=False,\n sampler=random_sampler)","def get_loader(split):\n assert split in ['train', 'val', 'trainval', 'test']\n image_feature_path = config.rcnn_trainval_path if split != 'test' else config.rcnn_test_path\n dataset = VQAFeatureDataset(\n split,\n image_feature_path,\n )\n loader = torch.utils.data.DataLoader(\n dataset,\n batch_size=512,\n shuffle=True if split not in ['val', 'test'] else False, # only shuffle the data in training\n pin_memory=True,\n num_workers=config.workers,\n )\n return loader","def get_dataloader(dataset, datadir, train_bs, test_bs, dataidxs=None, noise_level=0, net_id=None, total=0):\n if dataset in ('mnist', 'femnist', 'fmnist', 'cifar10','cifar100', 'svhn', 'generated', 'covtype', 'a9a', 'rcv1', 'SUSY','tinyimagenet'):\n if dataset == 'mnist':\n dl_obj = MNIST_truncated\n\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n elif dataset == 'femnist':\n dl_obj = FEMNIST\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n elif dataset == 'fmnist':\n dl_obj = FashionMNIST_truncated\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n elif dataset == 'svhn':\n dl_obj = SVHN_custom\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n\n elif dataset == 'cifar10':\n dl_obj = CIFAR10_truncated\n\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n transforms.Lambda(lambda x: F.pad(\n Variable(x.unsqueeze(0), requires_grad=False),\n (4, 4, 4, 4), mode='reflect').data.squeeze()),\n transforms.ToPILImage(),\n transforms.RandomCrop(32),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)\n ])\n # data prep for test set\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n \n elif dataset == 'cifar100':\n dl_obj = CIFAR100_truncated\n\n normalize = transforms.Normalize(mean=[0.5070751592371323, 0.48654887331495095, 0.4409178433670343],\n std=[0.2673342858792401, 0.2564384629170883, 0.27615047132568404])\n # transform_train = transforms.Compose([\n # transforms.RandomCrop(32),\n # transforms.RandomHorizontalFlip(),\n # transforms.ToTensor(),\n # normalize\n # ])\n transform_train = transforms.Compose([\n # transforms.ToPILImage(),\n transforms.RandomCrop(32, padding=4),\n transforms.RandomHorizontalFlip(),\n transforms.RandomRotation(15),\n transforms.ToTensor(),\n normalize\n ])\n # data prep for test set\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n normalize])\n\n elif dataset == 'tinyimagenet': \n # random_ids = np.random.randint(1000, size=datasize)\n # train_indices = random_ids\n\n imagenet_mean = [0.485, 0.456, 0.406]\n imagenet_std = [0.229, 0.224, 0.225]\n\n train_dl = torch.utils.data.DataLoader(\n torchvision.datasets.ImageFolder(datadir +\"/train\",\n transform=transforms.Compose([\n transforms.Resize(32), \n transforms.ToTensor(),\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\n #Phuong 09/26 drop_last=False -> True\n batch_size=train_bs, drop_last=True)\n \n test_dl = torch.utils.data.DataLoader(\n torchvision.datasets.ImageFolder(datadir +\"/test\",\n transform=transforms.Compose([\n transforms.Resize(32), \n transforms.ToTensor(),\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\n #Phuong 09/26 drop_last=False -> True\n batch_size=test_bs, drop_last=True)\n\n return train_dl, test_dl, None, None\n\n\n else:\n dl_obj = Generated\n transform_train = None\n transform_test = None\n\n\n train_ds = dl_obj(datadir, dataidxs=dataidxs, train=True, transform=transform_train, download=True)\n test_ds = dl_obj(datadir, train=False, transform=transform_test, download=True)\n\n train_dl = data.DataLoader(dataset=train_ds, batch_size=train_bs, shuffle=True, drop_last= dataset in ['cifar100'])\n test_dl = data.DataLoader(dataset=test_ds, batch_size=test_bs, shuffle=False, drop_last=False)\n\n return train_dl, test_dl, train_ds, test_ds","def __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)","def get_dataloader(self):\n shuffle = True if self.mode == \"train\" else False\n return DataLoader(self.get_dataset(), batch_size=self.batch_size, shuffle = shuffle, \n collate_fn=create_mini_batch)","def dataloaders():\n # train data path\n data_train = '../dataset/train/'\n # set transformations\n train_transforms = transforms.Compose([\n transforms.Resize((224, 224)),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n [0.229, 0.224, 0.225])])\n \n train_data = datasets.ImageFolder(data_train, transform = train_transforms)\n trainloader = torch.utils.data.DataLoader(train_data, batch_size = 16, shuffle = True)\n \n return trainloader","def get_data_loader(batch_size=10, num_workers=2):\n \n data_loader = torch.utils.data.DataLoader(dataset=TempuckeyDataSet(),\n batch_size=batch_size,\n shuffle=True,\n pin_memory=True,\n num_workers=num_workers,\n collate_fn=collate)\n return data_loader","def get_dataloader(dataset, batchsize):\n\n train_set_size = int(0.8 * dataset.__len__())\n train_indices = np.random.choice(np.arange(dataset.__len__()),\n train_set_size, replace=False)\n train_sampler = SubsetRandomSampler(train_indices)\n\n val_indices = np.setdiff1d(np.arange(dataset.__len__()),\n train_indices, assume_unique=True)\n val_sampler = SubsetRandomSampler(val_indices)\n\n trainloader = DataLoader(dataset, batch_size=batchsize,\n sampler=train_sampler, num_workers=2)\n valloader = DataLoader(dataset, batch_size=batchsize,\n sampler=val_sampler, num_workers=2)\n\n return trainloader, valloader","def data_loader(root, batch_size=64):\n input_transform = get_transform()\n dataset = CustomDataset(root, input_transform)\n return data.DataLoader(dataset=dataset,\n batch_size=batch_size,\n shuffle=False)","def get_train_loader(batch_size, train_set, train_sampler):\n train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, sampler=train_sampler, num_workers=4)\n\n return train_loader","def _custom_data_loader(self) -> DataLoader:\n dataloaders = DataLoader(self.dataset, batch_size=1)\n return dataloaders","def get_loader(data, json, batch_size, shuffle, num_workers):\n dataset = FinNumDataset(data, json)\n\n data_loader = torch.utils.data.DataLoader(dataset=dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n num_workers=num_workers,\n collate_fn=collate_fn)\n return data_loader","def test_dataloader(self) -> DataLoader:\n return self._custom_data_loader()","def build_training_data_loader(self) -> DataLoader:\n pass","def data_loader(\n self, batch_size: int = 1, iter_steps: int = 0, batch_as_list: bool = True\n ) -> DataLoader:\n data = self.data\n datasets = []\n\n for _, dat in data.items():\n datasets.append(dat.dataset())\n\n if len(datasets) < 1:\n raise FileNotFoundError(\n \"no datasets available for this model to create a loader from\"\n )\n\n return DataLoader(\n *datasets,\n batch_size=batch_size,\n iter_steps=iter_steps,\n batch_as_list=batch_as_list,\n )","def get_data_loaders(args, tokenizer):\n personachat = get_dataset(tokenizer, args.dataset_path, args.dataset_cache, args.train_lang)\n _ = personachat.pop(\"test\", None)\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": [], \"valid\": []}\n\n if args.train_lang in [\"En\", \"Fr\", \"It\", \"Id\", \"Jp\", \"Ko\", \"Zh\"]: #monolingual data\n for dataset_name, dataset in personachat.items():\n for dial in dataset[args.train_lang]: #dial: {\"persona\":[], \"history\":[], \"response\":str}\n instance = build_input_from_segments(dial[\"persona\"], dial[\"history\"][-args.max_turns:], dial[\"response\"], tokenizer, lm_labels = True)\n datasets[dataset_name].append(instance) \n else: #multilingual data\n for dataset_name, dataset in personachat.items():\n for lang, dials in dataset.items():\n for dial in dials: #dial: {\"persona\":[], \"history\":[], \"response\":str}\n instance = build_input_from_segments(dial[\"persona\"], dial[\"history\"][-args.max_turns:], dial[\"response\"], tokenizer, lang_id=\"<{}>\".format(lang.lower()), lm_labels = True)\n datasets[dataset_name].append(instance) #all langs together\n\n\n logger.info(\"Build train and validation dataloaders\")\n train_dataset = DatasetTrain(datasets[\"train\"])\n valid_dataset = DatasetTrain(datasets[\"valid\"])\n\n #logger.info(\"Build train and validation dataloaders\")\n #train_dataset, valid_dataset = TensorDataset(*tensor_datasets[\"train\"]), TensorDataset(*tensor_datasets[\"valid\"])\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) if args.distributed else None\n valid_sampler = torch.utils.data.distributed.DistributedSampler(valid_dataset) if args.distributed else None\n train_loader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size, shuffle=(not args.distributed), collate_fn=collate_fn)\n valid_loader = DataLoader(valid_dataset, sampler=valid_sampler, batch_size=args.valid_batch_size, shuffle=False, collate_fn=collate_fn)\n\n # logger.info(\"Train dataset (Batch, Candidates, Seq length): {}\".format(train_dataset.tensors[0].shape))\n # #logger.info(\"Train dataset (Batch, Candidates, Seq length): {}\".format(train_dataset.tensors[1].shape))\n # logger.info(\"Valid dataset (Batch, Candidates, Seq length): {}\".format(valid_dataset.tensors[0].shape))\n logger.info(\"Train dataset length: {}\".format(len(train_dataset)))\n logger.info(\"Valid dataset length: {}\".format(len(valid_dataset)))\n return train_loader, valid_loader, train_sampler, valid_sampler","def _init_al_dataset(self):\n\n self._init_dataset()\n\n train_dataset = self.datasets['train']\n\n dataset_size = len(train_dataset)\n self.budget = math.ceil(self.budget_frac*dataset_size)\n Sampler.__init__(self, config, self.budget) # TODO: Weird place to initialise this\n\n all_indices = set(np.arange(dataset_size))\n k_initial = math.ceil(len(all_indices)*self.initial_budget_frac)\n initial_indices = random.sample(list(all_indices), k=k_initial)\n\n sampler_init = data.sampler.SubsetRandomSampler(initial_indices) # need to sample from training dataset\n\n self.labelled_dataloader = data.DataLoader(train_dataset, sampler=sampler_init, batch_size=self.batch_size, drop_last=True)\n self.val_dataloader = data.DataLoader(self.datasets['valid'], batch_size=self.batch_size, drop_last=False)\n self.test_dataloader = data.DataLoader(self.datasets['test'], batch_size=self.batch_size, drop_last=False)\n\n return all_indices, initial_indices","def get_dataloaders(args):\n if args.dataset == 'heat':\n dataset_class = heat.HeatDiffusionDataset\n else:\n raise ValueError(f'Unknown dataset {args.dataset}')\n train_dataset = dataset_class(\n dataset_class.get_train_path(args.data_path), args, train=True)\n if args.dist:\n train_sampler = torch.utils.data.distributed.DistributedSampler(\n train_dataset)\n else:\n train_sampler = torch.utils.data.RandomSampler(train_dataset)\n train_loader = torch.utils.data.DataLoader(\n train_dataset, batch_size=args.batch_size, num_workers=args.workers,\n sampler=train_sampler, pin_memory=True, drop_last=args.drop_last)\n if not args.no_eval:\n validation_dataset = dataset_class(\n dataset_class.get_validation_path(args.data_path), args, train=False)\n if args.dist:\n validation_sampler = torch.utils.data.distributed.DistributedSampler(\n validation_dataset, shuffle=False)\n else:\n validation_sampler = torch.utils.data.SequentialSampler(\n validation_dataset)\n validation_loader = torch.utils.data.DataLoader(\n validation_dataset, batch_size=args.batch_size,\n num_workers=args.workers, sampler=validation_sampler,\n pin_memory=True, drop_last=args.drop_last)\n\n test_dataset = dataset_class(\n dataset_class.get_test_path(args.data_path), args, train=False)\n if args.dist:\n test_sampler = torch.utils.data.distributed.DistributedSampler(\n test_dataset, shuffle=False)\n else:\n test_sampler = torch.utils.data.SequentialSampler(\n test_dataset)\n test_loader = torch.utils.data.DataLoader(\n test_dataset, batch_size=args.batch_size,\n num_workers=args.workers, sampler=test_sampler,\n pin_memory=True, drop_last=args.drop_last)\n else:\n validation_loader = None\n test_loader = None\n\n # Update the data shape if needed.\n if args.data_shape is None:\n args.data_shape = train_dataset.get_shape()\n if args.data_target_shape is None:\n args.data_target_shape = train_dataset.get_target_shape()\n\n return train_loader, validation_loader, test_loader","def create_dataset_sampler_loader(file_path, cuda, batch_size, hvd):\n # When supported, use 'forkserver' to spawn dataloader workers\n # instead of 'fork' to prevent issues with Infiniband implementations\n # that are not fork-safe.\n kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}\n if (kwargs.get('num_workers', 0) > 0 and hasattr(mp, '_supports_context')\n and 'forkserver' in mp.get_all_start_methods()):\n kwargs['multiprocessing_context'] = 'forkserver'\n\n # create dataset\n dataset = MNISTDataset(file_path)\n # Horovod: use DistributedSampler to partition the training data\n sampler = Data.distributed.DistributedSampler(\n dataset, num_replicas=hvd.size(), rank=hvd.rank())\n loader = torch.utils.data.DataLoader(\n dataset, batch_size=batch_size, sampler=sampler, **kwargs)\n return dataset, sampler, loader","def to_DataLoader(self, **kwargs):\r\n return DataLoader(self, **kwargs)","def data_creator(config):\n train_dataset, val_dataset = LinearDataset(2, 5), LinearDataset(2, 5)\n train_loader = DataLoader(train_dataset, batch_size=config[\"batch_size\"])\n val_loader = DataLoader(val_dataset, batch_size=config[\"batch_size\"])\n return train_loader, val_loader","def make_dataloaders(params):\r\n transform_train = transforms.Compose([transforms.RandomCrop(32, padding=4),\r\n transforms.RandomHorizontalFlip(),\r\n transforms.ToTensor(),\r\n transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])])\r\n\r\n transform_validation = transforms.Compose([transforms.ToTensor(),\r\n transforms.Normalize([0.4914, 0.4822, 0.4465],\r\n [0.2023, 0.1994, 0.2010])])\r\n\r\n transform_validation = transforms.Compose([transforms.ToTensor()])\r\n\r\n trainset = torchvision.datasets.CIFAR10(root=params['path'], train=True, transform=transform_train)\r\n testset = torchvision.datasets.CIFAR10(root=params['path'], train=False, transform=transform_validation)\r\n\r\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=params['batch_size'], shuffle=True, num_workers=4)\r\n testloader = torch.utils.data.DataLoader(testset, batch_size=params['batch_size'], shuffle=False, num_workers=4)\r\n return trainloader, testloader","def load_data(batch_size=batch_size):\n trainset = LibriSpeechDataset(training_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds))\n testset = LibriSpeechDataset(validation_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds), stochastic=False)\n\n train_loader = DataLoader(trainset, batch_size=batch_size, num_workers=1, shuffle=True, drop_last=True)\n test_loader = DataLoader(testset, batch_size=1, num_workers=1, drop_last=True)\n\n return train_loader, test_loader","def initialize_dataloaders(\n self, X: Union[np.ndarray, pd.DataFrame], y: Union[np.ndarray, np.array]\n ):\n training_design_matrix, training_targets_array, validation_design_matrix, validation_targets_array = self.generate_training_validation_split(\n X, y\n )\n training_dataloader_kwargs = {\n \"design_matrix\": training_design_matrix,\n \"targets_array\": training_targets_array,\n \"data_type\": self.data_type,\n \"batch_size\": self.batch_size,\n \"shuffle\": self.shuffle_training_examples,\n }\n validation_dataloader_kwargs = {\n \"design_matrix\": validation_design_matrix,\n \"targets_array\": validation_targets_array,\n \"data_type\": self.data_type,\n \"batch_size\": self.batch_size,\n \"shuffle\": False,\n }\n self.training_dataloader = self.generate_dataloader(**training_dataloader_kwargs)\n self.validation_dataloader = self.generate_dataloader(**validation_dataloader_kwargs)","def get_dataloaders(data_dir,train_batch_size,val_batch_size,aug_flag):\n # Create the dataset object.\n transformed_dataset = PersonDataset(data_dir,False)\n # dataloader for train and validation\n validation_split = 0.2\n shuffle_dataset = True\n #random seed to keep the train-val split constant for inference purpose\n random_seed= 42\n # create indices for training and validation splits.\n dataset_size = len(transformed_dataset)\n # we create the indices using python range function and store it into a list\n indices = list(range(dataset_size))\n split = int(np.floor(validation_split*dataset_size))\n if shuffle_dataset:\n np.random.seed(random_seed)\n np.random.shuffle(indices)\n train_indices,val_indices = indices[split:],indices[:split]\n # create dataloaders...\n train_sampler = SubsetRandomSampler(train_indices)\n val_sampler = SubsetRandomSampler(val_indices)\n train_aug,val_aug = aug_flag,False\n train_loader = DataLoader(PersonDataset(data_dir,train_aug), batch_size=train_batch_size, shuffle=False, num_workers=0,sampler = train_sampler)\n val_loader = DataLoader(PersonDataset(data_dir,val_aug), batch_size=val_batch_size, shuffle=False, num_workers=0,sampler = val_sampler)\n\n # dictionary for data loaders..\n dataloaders = {\"train\" :train_loader,\n \"val\":val_loader\n }\n return dataloaders","def torch_dataset_loader(dataset, batch_size, shuffle, kwargs):\n loader = DataLoader(TorchData(dataset),\n batch_size=batch_size,\n shuffle=shuffle,\n **kwargs)\n return loader","def get_dataloader(data_folder, model_name, data_name, size=\"default\"):\n training_set = None\n validation_set = None\n\n if model_name == \"Howe_Patterson\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\n\n elif size == \"small\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\n elif size == \"tiny\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\n\n\n if data_name == \"SHHS\":\n training_set = Dataset_full_SHHS(partition['train'], data_folder)\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder)\n elif data_name == \"snooze\":\n training_set = Dataset_full(partition['train'], data_folder)\n validation_set = Dataset_full(partition['validation'], data_folder)\n elif data_name == \"philips\":\n training_set = Dataset_Philips_full(partition['train'], data_folder)\n validation_set = Dataset_Philips_full(partition['validation'], data_folder)\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n training_set = ConcatDataset(\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n validation_set = ConcatDataset(\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n elif model_name == \"Deep_Sleep\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\n\n elif size == \"small\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\n elif size == \"tiny\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\n\n if data_name == \"SHHS\":\n training_set = Dataset_full_SHHS(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"snooze\":\n training_set = Dataset_full(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_full(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"philips\":\n training_set = Dataset_Philips_full(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_Philips_full(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n # TODO combined dataset https://discuss.pytorch.org/t/train-simultaneously-on-two-datasets/649/17\n training_set = ConcatDataset(\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n validation_set = ConcatDataset(\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n elif model_name == \"ConvNet_IID\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition_IID_windows.pkl')))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition_IID_windows.pkl'))\n if data_name == \"SHHS\":\n training_set = Dataset_IID_window_SHHS(partition['train'], data_folder)\n validation_set = Dataset_IID_window_SHHS(partition['validation'], data_folder)\n elif data_name == \"snooze\":\n training_set = Dataset_IID_window(partition['train'], data_folder)\n validation_set = Dataset_IID_window(partition['validation'], data_folder)\n elif data_name == \"philips\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n training_set = ConcatDataset(\n Dataset_IID_window(partition[0]['train'], data_folder[0]),\n Dataset_IID_window_SHHS(partition[1]['train'], data_folder[1]))\n validation_set = ConcatDataset(\n Dataset_IID_window(partition[0]['validation'], data_folder[0]),\n Dataset_IID_window_SHHS(partition[1]['validation'], data_folder[1]))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n\n else:\n print(\"{} wrong model for dataloader\".format(model_name))\n exit()\n\n return training_set, validation_set","def get_loader(\n data_source: Iterable[dict],\n open_fn: Callable,\n dict_transform: Callable = None,\n sampler=None,\n collate_fn: Callable = default_collate_fn,\n batch_size: int = 32,\n num_workers: int = 4,\n shuffle: bool = False,\n drop_last: bool = False,\n):\n from catalyst.data.dataset import ListDataset\n\n dataset = ListDataset(\n list_data=data_source, open_fn=open_fn, dict_transform=dict_transform,\n )\n loader = torch.utils.data.DataLoader(\n dataset=dataset,\n sampler=sampler,\n collate_fn=collate_fn,\n batch_size=batch_size,\n num_workers=num_workers,\n shuffle=shuffle,\n pin_memory=torch.cuda.is_available(),\n drop_last=drop_last,\n )\n return loader","def val_dataloader(self):\r\n val_dataset = pv.data.Kinetics(\r\n data_path=os.path.join(self._DATA_PATH, \"val\"),\r\n clip_sampler=pv.data.make_clip_sampler(\"uniform\", self._CLIP_DURATION),\r\n decode_audio=False,\r\n )\r\n return torch.utils.data.DataLoader(\r\n val_dataset,\r\n batch_size=self._BATCH_SIZE,\r\n num_workers=self._NUM_WORKERS,\r\n )","def create_dataloaders(data_dir):\n\n trng_dataset = datasets.ImageFolder(data_dir / TRNG_FOLDER,\n transform=flowernet.trng_transform)\n trng_dataloader = torch.utils.data.DataLoader(trng_dataset,\n batch_size=64,\n shuffle=True)\n\n valn_dataset = datasets.ImageFolder(data_dir / VALN_FOLDER,\n transform=flowernet.pred_transform)\n valn_dataloader = torch.utils.data.DataLoader(valn_dataset,\n batch_size=64,\n shuffle=True)\n\n return trng_dataloader, valn_dataloader","def loadData(self):\n batch_size = 256\n \n #if self.conv_sg == True:\n # batch_size = 1 \n \n download = True\n root = self.root + self.dataset\n if self.dataset == \"MNIST\": \n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])\n trainset = torchvision.datasets.MNIST(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.MNIST(root, train=False, download=download, transform=transform)\n \n if self.dataset == \"CIFAR10\":\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465,), (0.2023, 0.1994, 0.2010,))])\n trainset = torchvision.datasets.CIFAR10(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.CIFAR10(root, train=False, download=download, transform=transform)\n \n if self.dataset == \"CIFAR100\":\n transform = transforms.Compose([transforms.ToTensor()])\n trainset = torchvision.datasets.CIFAR100(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.CIFAR100(root, train=False, download=download, transform=transform)\n \n \n trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size,\n shuffle=False, num_workers=0, pin_memory = False)\n \n testloader = torch.utils.data.DataLoader(testset, batch_size= batch_size,\n shuffle=False, num_workers=2, pin_memory = False)\n \n return trainloader, testloader","def train_dataloader(self, batch_size: Optional[int] = None) -> DataLoader:\n dataset = TabularDataset(\n task=self.config.task,\n data=self.train,\n categorical_cols=self.config.categorical_cols,\n continuous_cols=self.config.continuous_cols,\n embed_categorical=(not self.do_leave_one_out_encoder()),\n target=self.target,\n )\n return DataLoader(\n dataset,\n batch_size if batch_size is not None else self.batch_size,\n shuffle=True if self.train_sampler is None else False,\n num_workers=self.config.num_workers,\n sampler=self.train_sampler,\n pin_memory=self.config.pin_memory,\n )","def create_val_dataloader(configs, mode):\n val_sampler = None\n val_dataset = KittiDataset(configs, mode=mode, lidar_aug=None, hflip_prob=0., num_samples=configs.num_samples)\n if configs.distributed:\n val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset, shuffle=False)\n val_dataloader = DataLoader(val_dataset, batch_size=configs.batch_size, shuffle=False,\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=val_sampler)\n\n return val_dataloader","def load_dataset():\n\n\n train_dd_loader = DailyDialogLoader(PATH_TO_TRAIN_DATA, load=False)\n train_dataloader = DataLoader(train_dd_loader, batch_size=16, shuffle=True, num_workers=0,\n collate_fn=PadCollate())\n\n test_dd_loader = DailyDialogLoader(PATH_TO_TEST_DATA, load=True)\n test_dataloader = DataLoader(test_dd_loader, batch_size=1, shuffle=False, num_workers=0,\n collate_fn=PadCollate())\n\n assert train_dd_loader.vocabulary.n_words == test_dd_loader.vocabulary.n_words\n\n return train_dd_loader, train_dataloader, test_dataloader","def val_dataloader(self) -> DataLoader:\n return DataLoader(\n self.valid_dataset,\n batch_size=self.hparams.batch_size,\n shuffle=False,\n num_workers=multiprocessing.cpu_count(),\n )","def dataloader_msrvtt_train(args, tokenizer):\n\n msrvtt_train_set = MSRVTT_multi_sentence_dataLoader(\n csv_path=args.train_csv,\n json_path=args.data_path,\n features_path=args.features_path,\n max_words=args.max_words,\n feature_framerate=args.feature_framerate,\n tokenizer=tokenizer,\n max_frames=args.max_frames,\n )\n\n train_sampler = torch.utils.data.distributed.DistributedSampler(msrvtt_train_set)\n\n dataloader = DataLoader(\n msrvtt_train_set,\n batch_size=args.batch_size // args.n_gpu,\n num_workers=args.num_thread_reader,\n pin_memory=False,\n shuffle=(train_sampler is None),\n sampler=train_sampler,\n drop_last=True,\n )\n\n return dataloader, len(msrvtt_train_set), train_sampler","def load_dataloaders(args):\n logger.info(\"Loading dataloaders...\")\n p_path = os.path.join(\"./data/\", \"df_unencoded.pkl\")\n train_path = os.path.join(\"./data/\", \"df_encoded.pkl\")\n if (not os.path.isfile(p_path)) and (not os.path.isfile(train_path)):\n df = get_data(args, load_extracted=False)\n elif os.path.isfile(p_path) and (not os.path.isfile(train_path)):\n df = get_data(args, load_extracted=True)\n elif os.path.isfile(train_path):\n df = load_pickle(\"df_encoded.pkl\")\n \n # Train-Test split\n msk = np.random.rand(len(df)) < args.train_test_ratio\n trainset = df[msk]\n testset = df[~msk]\n \n trainset = text_dataset(trainset, args)\n max_features_length = trainset.max_x_len\n max_seq_len = trainset.max_y_len\n train_length = len(trainset)\n train_loader = DataLoader(trainset, batch_size=args.batch_size, shuffle=True,\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\n \n testset = text_dataset(testset, args)\n test_length = len(testset)\n test_loader = DataLoader(testset, batch_size=args.batch_size, shuffle=True,\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\n return train_loader, train_length, max_features_length, max_seq_len, test_loader, test_length","def val_dataloader(self) -> data.DataLoader:\n return data.DataLoader(dataset=self.datasets['valid'], batch_size=self.batch_size,\n num_workers=self.num_workers, shuffle=False, pin_memory=False)","def create_test_dataloader(configs):\n\n test_dataset = KittiDataset(configs, mode='test', lidar_aug=None, hflip_prob=0., num_samples=configs.num_samples)\n test_sampler = None\n if configs.distributed:\n test_sampler = torch.utils.data.distributed.DistributedSampler(test_dataset)\n test_dataloader = DataLoader(test_dataset, batch_size=configs.batch_size, shuffle=False,\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=test_sampler)\n\n return test_dataloader","def creates_data_loader():\n dataset_faces = FaceDataset(\n IMG_DIR, transform=transform_train, face=True)\n\n dataset_no_faces = FaceDataset(\n IMG_DIR, transform=transform_train, face=False)\n\n datasets_faces_split = train_val_test(dataset_faces, 0.2, 0.0)\n datasets_no_faces_split = train_val_test(dataset_no_faces, 0.2, 0.0)\n\n datasets = {}\n datasets[\"train\"] = datasets_faces_split[\"train\"] + \\\n datasets_no_faces_split[\"train\"]\n datasets[\"test\"] = datasets_no_faces_split[\"test\"]\n datasets[\"val\"] = datasets_faces_split[\"val\"] + \\\n datasets_no_faces_split[\"val\"]\n\n train_loader = DataLoader(dataset=datasets[\"train\"], batch_size=BATCH_SIZE,\n num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False)\n\n val_loader = DataLoader(dataset=datasets[\"val\"], batch_size=BATCH_SIZE,\n num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False)\n return train_loader, val_loader","def get_loader(dataset='train.txt', crop_size=128, image_size=28, batch_size=2, mode='train', num_workers=1): \n transform = [] \n if mode == 'train': \n transform.append(transforms.RandomHorizontalFlip()) \n transform.append(transforms.CenterCrop(crop_size)) \n transform.append(transforms.Resize(image_size)) \n transform.append(transforms.ToTensor()) \n transform.append(transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) \n transform = transforms.Compose(transform) \n train_data=MyDataset(txt=dataset, transform=transform) \n data_loader = DataLoader(dataset=train_data, \n batch_size=batch_size, \n shuffle=(mode=='train'), \n num_workers=num_workers) \n return data_loader","def get_loader(data_list, config, train=True):\n \n with open(config[\"label_map\"], \"r\") as f:\n label_map = json.load(f)\n\n dataset = GoogleSpeechDataset(\n data_list=data_list,\n label_map=label_map,\n audio_settings=config[\"hparams\"][\"audio\"],\n aug_settings=config[\"hparams\"][\"augment\"] if train else None,\n cache=config[\"exp\"][\"cache\"]\n )\n\n dataloader = DataLoader(\n dataset,\n batch_size=config[\"hparams\"][\"batch_size\"],\n num_workers=config[\"exp\"][\"n_workers\"],\n pin_memory=config[\"exp\"][\"pin_memory\"],\n shuffle=True if train else False\n )\n\n return dataloader","def prepare_anndata(anndata, batch_size, shuffle=False):\n # Add shuffling here\n if sparse.issparse(anndata.X):\n data = anndata.X.A\n else:\n data = anndata.X\n data = torch.Tensor(data)\n my_dataloader = torch.utils.data.DataLoader(data, shuffle=shuffle, batch_size=batch_size)\n return my_dataloader","def fetch_dataloader(types, data_dir, hyper_params, train_idx=None, val_idx=None):\n dataloaders = {}\n \n # TODO: write this to hyper_params, make hyper_params an out variable? then save? yes, AND: when ONLY test is requested, load from hyperparams!\n # TODO: also, add 3rd variation of types: for testing, only read it from hyper_params (DO I NEED TO READ HYPER_PARAMS FOR JUST TESTING?)\n if train_idx is not None:\n mean, std = mean_std_calc(DataLoader(Subset(Heart2DSegmentationDataset(str(Path(data_dir) / \"train_heart_scans\"), hyper_params.endo_or_epi), train_idx)))\n hyper_params.mean = mean.item()\n hyper_params.std = std.item()\n else:\n if 'train' in types:\n mean, std = mean_std_calc(DataLoader(Heart2DSegmentationDataset(str(Path(data_dir) / \"train_heart_scans\"), hyper_params.endo_or_epi)))\n hyper_params.mean = mean.item()\n hyper_params.std = std.item()\n else:\n mean, std = torch.tensor(hyper_params.mean), torch.tensor(hyper_params.std)\n \n print(\"Mean: {}, Std: {}\".format(mean.item(), std.item()))\n # borrowed from http://pytorch.org/tutorials/advanced/neural_style_tutorial.html\n # and http://pytorch.org/tutorials/beginner/data_loading_tutorial.html\n train_transformer = transforms.Compose([\n transforms.Normalize(mean=[mean.item()], std=[std.item()])\n ])\n \n eval_transformer = transforms.Compose([\n transforms.Normalize(mean=[mean.item()], std=[std.item()])\n ])\n\n for split in ['train', 'val', 'test']:\n if split in types:\n path = str(Path(data_dir) / \"{}_heart_scans\".format(split if split != 'val' else 'train'))\n\n if split == 'train':\n if train_idx is not None:\n dl = DataLoader(Subset(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, train_transformer), train_idx), \n batch_size=hyper_params.batch_size, \n shuffle=True,\n num_workers=hyper_params.num_workers,\n pin_memory=hyper_params.cuda)\n else:\n dl = DataLoader(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, train_transformer), \n batch_size=hyper_params.batch_size, \n shuffle=True,\n num_workers=hyper_params.num_workers,\n pin_memory=hyper_params.cuda)\n else:\n if (split == 'val') and (val_idx is not None): \n dl = DataLoader(Subset(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, eval_transformer), val_idx), \n batch_size=hyper_params.batch_size, \n shuffle=False,\n num_workers=hyper_params.num_workers,\n pin_memory=hyper_params.cuda) \n else:\n dl = DataLoader(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, eval_transformer), \n batch_size=hyper_params.batch_size, \n shuffle=False,\n num_workers=hyper_params.num_workers,\n pin_memory=hyper_params.cuda)\n\n dataloaders[split] = dl\n\n return dataloaders","def get_dataloader(\n path='data/interim/data.json',\n train_test_split=0.8,\n batch_size_train=5,\n batch_size_test=5,\n shuffle_train=True,\n perm_images=True,\n transform_train=True,\n transform_test=False,\n class_names=None):\n\n # use our dataset and defined transformations\n if class_names is None:\n dataset = ProdigyDataReader(path, get_transforms(train=transform_train))\n dataset_test = ProdigyDataReader(path, get_transforms(train=transform_test))\n else:\n dataset = ProdigyDataReader(path, get_transforms(train=transform_train),\n object_categories=class_names)\n dataset_test = ProdigyDataReader(path, get_transforms(train=transform_test),\n object_categories=class_names)\n\n # split the dataset in train and test set\n if perm_images:\n indices = torch.randperm(len(dataset)).tolist()\n else:\n indices = list(range(len(dataset)))\n\n len_train = int(len(indices) * train_test_split)\n dataset = torch.utils.data.Subset(dataset, indices[:len_train])\n dataset_test = torch.utils.data.Subset(dataset_test, indices[len_train:])\n\n # define training and validation data loaders\n data_loader = torch.utils.data.DataLoader(\n dataset, batch_size=batch_size_train, shuffle=shuffle_train, num_workers=0,\n collate_fn=collate_fn)\n\n data_loader_test = torch.utils.data.DataLoader(\n dataset_test, batch_size=batch_size_test, shuffle=False, num_workers=0,\n collate_fn=collate_fn)\n\n return [data_loader, data_loader_test]","def get_val_dataloader(dataset, datadir, datasize, val_bs):\n val_dl = None\n if dataset == 'tinyimagenet':\n if not os.path.exists('./data/tiny-imagenet-200'):\n download_and_unzip('http://cs231n.stanford.edu/tiny-imagenet-200.zip','./data/')\n random_ids = np.random.randint(100000, size=datasize)\n val_indices = random_ids\n\n imagenet_mean = [0.485, 0.456, 0.406]\n imagenet_std = [0.229, 0.224, 0.225]\n\n val_dl = torch.utils.data.DataLoader(\n torchvision.datasets.ImageFolder(datadir,\n transform=transforms.Compose([\n transforms.Resize(32), \n transforms.ToTensor(),\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\n #Phuong 09/26 drop_last=False -> True\n batch_size=val_bs, drop_last=True, sampler=SubsetRandomSampler(val_indices))\n \n elif dataset == 'fmnist':\n dl_obj = FashionMNIST_truncated\n transform_val = transforms.Compose([\n transforms.ToTensor(),])\n \n random_ids = np.random.randint(10000, size=datasize)\n val_indices = random_ids\n\n val_ds = dl_obj(datadir, dataidxs=val_indices, train=True, transform=transform_val, download=True)\n val_dl = torch.utils.data.DataLoader(dataset=val_ds, batch_size=val_bs, shuffle=True, drop_last=False)\n \n elif dataset == \"cifar10\":\n dl_obj = CIFAR10_truncated\n transform_val = transforms.Compose([\n transforms.ToTensor(),\n transforms.Lambda(lambda x: F.pad(\n Variable(x.unsqueeze(0), requires_grad=False),\n (4, 4, 4, 4), mode='reflect').data.squeeze()),\n transforms.ToPILImage(),\n transforms.RandomCrop(32, padding=4),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\n transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),\n # transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n\n ])\n random_ids = np.random.randint(10000, size=datasize)\n val_indices = random_ids\n\n val_ds = dl_obj(datadir, dataidxs=val_indices, train=True, transform=transform_val, download=True)\n val_dl = torch.utils.data.DataLoader(dataset=val_ds, batch_size=val_bs, shuffle=True, drop_last=False)\n\n\n return val_dl","def _load_data(self):\n if self._name in BALANCE_DATASET:\n _loader = dataset_loaders[self._name]\n xnp, y = _loader()\n\n # Train - Test split\n gen = ShuffleSplit(n_splits=1, random_state=42, test_size=self._test_size).split(xnp)\n train_idx, test_idx = next(gen)\n\n # Train data.\n self.xnp_tr = xnp[train_idx]\n self.y_tr = y[train_idx]\n # Test data.\n self.xnp_ts = xnp[test_idx]\n self.y_ts = y[test_idx]\n\n else:\n _loader = dataset_loaders[self._name]\n xnp, xp, y = _loader()\n # self.xnp, self.xp, self.y = _loader()\n\n # Train - Test split\n gen = ShuffleSplit(n_splits=1, random_state=42, test_size=self._test_size).split(xnp)\n train_idx, test_idx = next(gen)\n\n # Train data.\n self.xnp_tr = xnp[train_idx]\n self.xp_tr = xp[train_idx]\n self.y_tr = y[train_idx]\n # Test data.\n self.xnp_ts = xnp[test_idx]\n self.xp_ts = xp[test_idx]\n self.y_ts = y[test_idx]","def prepare_demo_dataset(path, reso, batch_size=1):\r\n transform = transforms.Compose([\r\n transforms.Resize(size=(reso, reso), interpolation=3),\r\n transforms.ToTensor()\r\n ])\r\n\r\n img_datasets = DemoDataset(path, transform)\r\n dataloader = torch.utils.data.DataLoader(img_datasets, batch_size=batch_size, num_workers=8)\r\n\r\n return img_datasets, dataloader","def training_start(self, dataloader):\n self.datasize = len(dataloader)","def get_test_loader(id_list = './data/sample_submission.csv', root_dir = './data/test/'):\n data = HumanProteinDataset(id_list, root_dir, transform = transforms.Compose([\n Rescale((256, 256)), \n ToTensor()\n ]))\n\n indices = np.arange(len(data))\n dataloader_test = DataLoader(data, batch_size=10, num_workers=5)\n\n return dataloader_test","def train(self, data):\n pass","def make_data_loader(examples, batch_size=100, shuffle=True):\n x, y = zip(*examples) # makes lists of windows and tags\n x, y = tr.from_numpy(np.array(x)), tr.from_numpy(np.array(y))\n x, y = x.type(tr.LongTensor), y.type(tr.LongTensor) # convert lists to tensors\n train = utdata.TensorDataset(x, y)\n return utdata.DataLoader(train, batch_size, shuffle)","def create_trainval_dataloaders(params):\n # ----------------Create Dataset objects and Dataloaders----------------\n mr_dataset_train, tokenizer = get_dataset(params, run_mode=\"train\")\n params.vocab_size = tokenizer.get_vocab_size()\n print(\"SystemLog: Vocab size used for training is %d\" % (params.vocab_size))\n print(\"SystemLog: Number of items in the train dataset=%d\" % len(mr_dataset_train))\n sys.stdout.flush()\n # Collate Function pads the sequences to have a uniform length for the entire batch\n mr_dataloader_train = DataLoader(mr_dataset_train, batch_size=params.batch_size,\n shuffle=True, num_workers=params.num_workers, collate_fn=CollateMRSequence(params.architecture))\n\n mr_dataset_valid, _ = get_dataset(params, run_mode=\"valid\")\n print(\"SystemLog: Number of items in the valid dataset=%d\" % len(mr_dataset_valid))\n mr_dataloader_valid = DataLoader(mr_dataset_valid, batch_size=params.batch_size_validation,\n shuffle=False, num_workers=0, collate_fn=CollateMRSequence(params.architecture))\n\n return mr_dataset_train, mr_dataloader_train, mr_dataset_valid, mr_dataloader_valid","def build_dataloader(cfg, augmentor=None, mode='train', dataset=None, rank=None,\n dataset_class=VolumeDataset, dataset_options={}, cf=collate_fn_train):\n assert mode in ['train', 'val', 'test']\n print('Mode: ', mode)\n\n if mode == 'train':\n batch_size = cfg.SOLVER.SAMPLES_PER_BATCH\n elif mode == 'val':\n batch_size = cfg.SOLVER.SAMPLES_PER_BATCH * 4\n else:\n cf = collate_fn_test # update the collate function\n batch_size = cfg.INFERENCE.SAMPLES_PER_BATCH * cfg.SYSTEM.NUM_GPUS\n\n if dataset is None: # no pre-defined dataset instance\n if cfg.MODEL.TARGET_OPT_MULTISEG_SPLIT is not None:\n dataset_class = VolumeDatasetMultiSeg\n dataset = get_dataset(cfg, augmentor, mode, rank, dataset_class, dataset_options)\n\n sampler = None\n num_workers = cfg.SYSTEM.NUM_CPUS\n if cfg.SYSTEM.DISTRIBUTED:\n num_workers = cfg.SYSTEM.NUM_CPUS // cfg.SYSTEM.NUM_GPUS\n if cfg.DATASET.DISTRIBUTED == False:\n sampler = torch.utils.data.distributed.DistributedSampler(dataset)\n\n # In PyTorch, each worker will create a copy of the Dataset, so if the data\n # is preload the data, the memory usage should increase a lot.\n # https://discuss.pytorch.org/t/define-iterator-on-dataloader-is-very-slow/52238/2\n img_loader = torch.utils.data.DataLoader(\n dataset, batch_size=batch_size, shuffle=False, collate_fn=cf,\n sampler=sampler, num_workers=num_workers, pin_memory=True)\n\n return img_loader","def dataio_prepare(hparams):\n data_folder = hparams[\"data_folder\"]\n\n train_data = dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"train_data\"],\n replacements={\"data_root\": data_folder}, )\n\n if hparams[\"sorting\"] == \"ascending\":\n # we sort training data to speed up training and get better results.\n train_data = train_data.filtered_sorted(sort_key=\"duration\")\n # when sorting do not shuffle in dataloader ! otherwise is pointless\n hparams[\"train_dataloader_opts\"][\"shuffle\"] = False\n\n elif hparams[\"sorting\"] == \"descending\":\n train_data = train_data.filtered_sorted(\n sort_key=\"duration\", reverse=True)\n # when sorting do not shuffle in dataloader ! otherwise is pointless\n hparams[\"train_dataloader_opts\"][\"shuffle\"] = False\n\n elif hparams[\"sorting\"] == \"random\":\n pass\n\n else:\n raise NotImplementedError(\n \"sorting must be random, ascending or descending\")\n\n valid_data = dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"valid_data\"],\n replacements={\"data_root\": data_folder}, )\n valid_data = valid_data.filtered_sorted(sort_key=\"duration\")\n\n test_data = dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"test_data\"],\n replacements={\"data_root\": data_folder}, )\n test_data = test_data.filtered_sorted(sort_key=\"duration\")\n\n datasets = [train_data, valid_data, test_data]\n\n # Defining tokenizer and loading it\n tokenizer = transformers.BertTokenizer.from_pretrained('bert-base-chinese')\n\n # 2. Define audio pipeline:\n @data_pipeline.takes(\"wav\")\n @data_pipeline.provides(\"sig\")\n def audio_pipeline(wav):\n sig = dataio.read_audio(wav)\n return sig\n\n dataset.add_dynamic_item(datasets, audio_pipeline)\n\n # 3. Define text pipeline:\n @data_pipeline.takes(\"transcript\")\n @data_pipeline.provides(\"wrd\", \"tokens_list\", \"tokens\")\n def text_pipeline(wrd):\n wrd = \"\".join(wrd.split(\" \"))\n yield wrd\n tokens_list = tokenizer(wrd)[\"input_ids\"]\n yield tokens_list\n tokens = numpy.array(tokens_list, dtype=\"int64\")\n yield tokens\n\n dataset.add_dynamic_item(datasets, text_pipeline)\n\n # 4. Set output:\n dataset.set_output_keys(\n datasets,\n [\"id\", \"sig\", \"wrd\", \"tokens\"], )\n\n # 5. If Dynamic Batching is used, we instantiate the needed samplers.\n train_batch_sampler = None\n valid_batch_sampler = None\n if hparams[\"dynamic_batching\"]:\n from sampler import DynamicBatchSampler # noqa\n\n dynamic_hparams = hparams[\"dynamic_batch_sampler\"]\n num_buckets = dynamic_hparams[\"num_buckets\"]\n\n train_batch_sampler = DynamicBatchSampler(\n train_data,\n dynamic_hparams[\"max_batch_len\"],\n num_buckets=num_buckets,\n length_func=lambda x: x[\"duration\"],\n shuffle=dynamic_hparams[\"shuffle_ex\"],\n batch_ordering=dynamic_hparams[\"batch_ordering\"], )\n\n valid_batch_sampler = DynamicBatchSampler(\n valid_data,\n dynamic_hparams[\"max_batch_len\"],\n num_buckets=num_buckets,\n length_func=lambda x: x[\"duration\"],\n shuffle=dynamic_hparams[\"shuffle_ex\"],\n batch_ordering=dynamic_hparams[\"batch_ordering\"], )\n\n return (train_data, valid_data, test_data, tokenizer, train_batch_sampler,\n valid_batch_sampler, )","def prepare_data(self,d):\n train_loaders, train_iters = {}, {}\n unlabeled_loaders, unlabeled_iters = {}, {}\n for domain in opt.domains:\n #CONVERT TO FLOAT32\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\n train = data_utils.TensorDataset(features,target)\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\n train_iters[domain] = iter(train_loaders[domain])\n for domain in opt.unlabeled_domains:\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\n uset = data_utils.TensorDataset(features,target)\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\n \n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters","def test_dataloader(self, batch_size: Optional[int] = None) -> DataLoader:\n if self.test is not None:\n dataset = TabularDataset(\n task=self.config.task,\n data=self.test,\n categorical_cols=self.config.categorical_cols,\n continuous_cols=self.config.continuous_cols,\n embed_categorical=(not self.do_leave_one_out_encoder()),\n target=self.target,\n )\n return DataLoader(\n dataset,\n batch_size if batch_size is not None else self.batch_size,\n shuffle=False,\n num_workers=self.config.num_workers,\n pin_memory=self.config.pin_memory,\n )","def get_each_loader(data_path, batch_size, trn_negnum, shuffle=True, num_workers=0):\n \n dataset = ML_Dataset(data_path, trn_negnum)\n \n if data_path.endswith('trn') == True:\n collate = dataset.train_collate\n else:\n collate = test_collate\n\n data_loader = data.DataLoader(dataset=dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n num_workers=num_workers,\n collate_fn=collate)\n\n return data_loader","def __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)\n \n self._results_ = None","def train(self, train_loader):\n pass","def load_data(self,split='train'):\n raise NotImplementedError","def get_dataloader(hp: HParams) \\\n -> Tuple[torch.utils.data.DataLoader, torch.utils.data.DataLoader, int]:\n if hp.data.dataset == \"podcast\":\n dataset = podcast.PODCAST(root=hp.data.path,\n audio_folder=hp.data.audio_folder,\n text_file=hp.data.text_file)\n length = len(dataset)\n train_length = int(0.9 * length)\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\n length - train_length])\n\n # https://towardsdatascience.com/7-tips-for-squeezing-maximum-performance-from-pytorch-ca4a40951259\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n return train_dataloader, test_dataloader, int(0.9 * length)\n\n elif hp.data.dataset == \"librispeech\":\n Path(hp.data.path).mkdir(parents=True, exist_ok=True)\n dataset = librispeech.download_data(root=hp.data.path, url=hp.data.url)\n length = len(dataset)\n train_length = int(0.9 * length)\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\n length - train_length])\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n return train_dataloader, test_dataloader, int(0.9 * length)\n\n elif hp.data.dataset == \"ljspeech\":\n Path(hp.data.path).mkdir(parents=True, exist_ok=True)\n dataset = ljspeech.download_data(root=hp.data.path)\n length = len(dataset)\n train_length = int(0.9 * length)\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\n length - train_length])\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n\n return train_dataloader, test_dataloader, int(0.9 * length)\n\n else:\n raise Exception(f\"Dataset {hp.data.dataset} does not exist\")","def get_dataloader(params, format_name='hdf5', **kwargs):\n \n Provider = get_proper_provider(format_name)(params.modality)\n \n return DataLoader(Provider(params.dataset_path,\n seq_length=params.seq_length),\n batch_size=params.batch_size,\n shuffle=params.is_training,\n num_workers=params.num_workers,\n pin_memory=params.cuda,\n collate_fn=pad_collate)","def load_data(self,split='train'):\n return load_arrow_data(self.config,split)","def data_loader(edges,features,y):\n\n\n edge_index = torch.tensor(edges, dtype=torch.long)\n edge_index = edge_index.t().contiguous()\n x = torch.tensor(features.todense(), dtype=torch.float)\n\n y = torch.tensor(y)\n\n data = Data(x=x, edge_index=edge_index, y = y)\n\n return data","def load_data(data_feeder):\n return data_feeder(BATCH_SIZE,\n SEQ_LEN,\n OVERLAP,\n Q_LEVELS,\n Q_ZERO,\n Q_TYPE)","def load(self, config, dataset_type, *args, **kwargs):\n base_dataset_name = config.get(\"base_dataset_name\", \"vqa2\")\n base_dataset_config = config.get(\"base_dataset\", config)\n # instantiate base dataset\n # instantiate base dataser builder\n base_dataset_builder_class = registry.get_builder_class(base_dataset_name)\n base_dataset_builder_instance = base_dataset_builder_class()\n # build base dataset instance\n base_dataset_builder_instance.build_dataset(base_dataset_config)\n base_dataset = base_dataset_builder_instance.load_dataset(\n base_dataset_config, dataset_type\n )\n if hasattr(base_dataset_builder_instance, \"update_registry_for_model\"):\n base_dataset_builder_instance.update_registry_for_model(base_dataset_config)\n\n # instantiate vinvl dataset\n vinvl_text_processor = config[\"processors\"][\"text_processor\"]\n with open_dict(base_dataset_config):\n base_dataset_config[\"processors\"][\"text_processor\"] = vinvl_text_processor\n base_dataset_config[\"label_map\"] = config[\"label_map\"]\n\n vinvl_dataset = super().load(base_dataset_config, dataset_type, *args, **kwargs)\n vinvl_dataset.set_base_dataset(base_dataset)\n return vinvl_dataset","def create_dataloader(datafile, dataset_type, batch_size, mechanism, shuffle=False):\n dataset = MazeDataset(datafile, dataset_type)\n assert dataset.num_actions == mechanism.num_actions\n return torch.utils.data.DataLoader(\n dataset, batch_size=batch_size, shuffle=shuffle, num_workers=0)","def __init__(self, dataloader):\n self._dataloader = dataloader\n\n self._iterator = iter(self._dataloader)","def test_cached_dataloader(self):\n\n v = [\"data\", \"target\", \"model_out_sqnet\"]\n\n for data, target in self.train_loader:\n b, c, h, w = data[v[0]].shape\n assert data[v[1]].shape == (b, )\n assert data[v[2]].shape == (b, 100)\n assert data[v[1]].shape == target.shape","def view(\n self,\n collate_fn: Union[callable, str] = \"batch_of_g_and_y\",\n *args,\n **kwargs\n ):\n # provide default collate function\n if isinstance(collate_fn, str):\n collate_fn = getattr(self, collate_fn)\n\n return torch.utils.data.DataLoader(\n dataset=self,\n collate_fn=collate_fn,\n *args,\n **kwargs,\n )","def get_test_loader(test_dataset,\n batch_size,\n num_workers=4,\n pin_memory=False):\n data_loader = torchutils.DataLoader(\n test_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=pin_memory)\n return data_loader","def get_loader(file_path, src_word2id, trg_word2id, intent_type=None, intent2index=None, batch_size=1):\n dials = json.load(open(file_path))\n dataset_list = []\n for name in dials.keys():\n val_file = dials[name]\n # build a custom dataset\n dataset = MultiwozSingleDataset(val_file, name, src_word2id, trg_word2id, intent_type, intent2index)\n dataset_list.append(dataset)\n datasets = ConcatDataset(dataset_list)\n # data loader for custome dataset\n data_loader = DataLoader(dataset=datasets,\n batch_size=batch_size,\n shuffle=True,\n num_workers=0,\n collate_fn=collate_fn)\n return data_loader","def get_dataloader(self, cid, batch_size=None, type=\"train\"):\n dataset = self.get_dataset(cid, type)\n batch_size = len(dataset) if batch_size is None else batch_size\n data_loader = DataLoader(dataset, batch_size=batch_size)\n return data_loader","def dataloader_vatexEnglish_test(args, tokenizer, subset=\"test\"):\n\n vatexEnglish_dataset = VATEXENGLISH_multi_sentence_dataLoader(\n subset=subset,\n data_path=args.data_path,\n features_path=args.features_path,\n max_words=args.max_words,\n feature_framerate=args.feature_framerate,\n tokenizer=tokenizer,\n max_frames=args.max_frames,\n )\n\n dataloader = DataLoader(\n vatexEnglish_dataset,\n batch_size=args.batch_size_val,\n num_workers=args.num_thread_reader,\n shuffle=False,\n drop_last=False,\n )\n return dataloader, len(vatexEnglish_dataset)","def load(self, handler, name, size, \n batch_size=None, shuffle=False, \n sample_transform=None, batch_transform=None):\n if sample_transform is None:\n sample_transform = self.sample_transform\n if batch_transform is None:\n batch_transform = self.batch_transform\n dataset = DatasetIterator(name, size, handler, \n shuffle=shuffle,\n transform=sample_transform)\n if batch_size is None:\n return dataset\n batches = BatchIterator(dataset, \n batch_size=batch_size, \n transform=batch_transform)\n return batches","def get_dataloader(\n trainset: VisionDataset,\n testset: VisionDataset,\n batch_size: int,\n n_workers: int,\n) -> Tuple[data.DataLoader, data.DataLoader]:\n trainloader = data.DataLoader(\n trainset,\n pin_memory=(torch.cuda.is_available()),\n num_workers=n_workers,\n shuffle=True,\n batch_size=batch_size,\n )\n testloader = data.DataLoader(\n testset,\n pin_memory=(torch.cuda.is_available()),\n num_workers=n_workers,\n shuffle=False,\n batch_size=batch_size,\n )\n return trainloader, testloader","def build_dataset(input_reader_config,\n model_config,\n training,\n voxel_generator,\n target_assigner=None):\n generate_bev = model_config.POST_PROCESSING.use_bev\n without_reflectivity = model_config.WITHOUT_REFLECTIVITY\n num_point_features = model_config.NUM_POINT_FEATURES\n out_size_factor = model_config.BACKBONE.layer_strides[0] //model_config.BACKBONE.upsample_strides[0]\n cfg = input_reader_config\n db_sampler_cfg = input_reader_config.DATABASE_SAMPLER\n db_sampler = None\n if len(db_sampler_cfg.sample_groups) > 0:\n db_sampler = build_dbsampler(db_sampler_cfg)\n try:\n u_db_sampler_cfg = input_reader_config.UNLABELED_DATABASE_SAMPLER\n u_db_sampler = None \n if len(u_db_sampler_cfg.sample_groups) > 0:\n u_db_sampler = build_dbsampler(u_db_sampler_cfg)\n except:\n u_db_sampler = None\n grid_size = voxel_generator.grid_size #[352,400]\n feature_map_size = grid_size[:2] // out_size_factor\n feature_map_size = [*feature_map_size, 1][::-1]\n\n prep_func = partial(\n prep_pointcloud,\n root_path = cfg.KITTI_ROOT_PATH,\n class_names = cfg.CLASS_NAMES,\n voxel_generator=voxel_generator,\n target_assigner=target_assigner,\n training=training,\n max_voxels = cfg.MAX_NUMBER_OF_VOXELS,\n remove_outside_points = False,\n create_targets = training,\n shuffle_points = cfg.SHUFFLE_POINTS,\n gt_rotation_noise = cfg.GROUNDTRUTH_ROTATION_UNIFORM_NOISE,\n gt_loc_noise_std = cfg.GROUNDTRUTH_LOCALIZATION_NOISE_STD,\n global_rotation_noise = cfg.GLOBAL_ROTATION_UNIFORM_NOISE,\n global_scaling_noise = cfg.GLOBAL_SCALING_UNIFORM_NOISE,\n global_loc_noise_std = (0.2, 0.2, 0.2),\n global_random_rot_range = cfg.GLOBAL_RANDOM_ROTATION_RANGE_PER_OBJECT,\n db_sampler = db_sampler,\n unlabeled_db_sampler = u_db_sampler,\n generate_bev = generate_bev,\n without_reflectivity=without_reflectivity,\n num_point_features=num_point_features,\n anchor_area_threshold=cfg.ANCHOR_AREA_THRESHOLD,\n gt_points_drop=cfg.GROUNDTRUTH_POINTS_DROP_PERCENTAGE,\n gt_drop_max_keep=cfg.GROUNDTRUTH_DROP_MAX_KEEP_POINTS,\n remove_points_after_sample=cfg.REMOVE_POINTS_AFTER_SAMPLE,\n remove_environment=cfg.REMOVE_ENVIRONMENT,\n use_group_id=False,\n out_size_factor=out_size_factor)\n dataset = KittiDataset(\n info_path = cfg.KITTI_INFO_PATH,\n root_path=cfg.KITTI_ROOT_PATH,\n num_point_features=num_point_features,\n target_assigner=target_assigner,\n feature_map_size=feature_map_size,\n prep_func=prep_func\n )\n return dataset","def dataset(options):\n pass","def get_loaders(opt):\n train_samples, val_samples = get_train_val_metadata(opt.dataset_dir,\n opt.validation_cities,\n opt.patch_size,\n opt.stride)\n print('train samples : ', len(train_samples))\n print('val samples : ', len(val_samples))\n\n logging.info('STARTING Dataset Creation')\n\n full_load = full_onera_loader(opt.dataset_dir, opt)\n\n train_dataset = OneraPreloader(opt.dataset_dir,\n train_samples,\n full_load,\n opt.patch_size,\n opt.augmentation)\n val_dataset = OneraPreloader(opt.dataset_dir,\n val_samples,\n full_load,\n opt.patch_size,\n False)\n\n logging.info('STARTING Dataloading')\n\n train_loader = torch.utils.data.DataLoader(train_dataset,\n batch_size=opt.batch_size,\n shuffle=True,\n num_workers=opt.num_workers)\n val_loader = torch.utils.data.DataLoader(val_dataset,\n batch_size=opt.batch_size,\n shuffle=False,\n num_workers=opt.num_workers)\n return train_loader, val_loader","def val_dataloader(self) -> DataLoader:\n loader_val = DataLoader(\n self.dataset_valid, \n batch_size=int(1.5 * self.args.batch_size),\n num_workers=self.args.num_workers,\n pin_memory=self.args.pin_mem,\n drop_last=False\n )\n return loader_val"],"string":"[\n \"def train_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)\",\n \"def dataloader(self):\\n\\n # load / split data\\n train_data = self.data.get_train_data()\\n if self.args.use_dev:\\n train_data, dev_data = self.data.split_data(train_data)\\n test_data = self.data.get_test_data()\\n\\n #print(train_data[0])\\n #print(dev_data[0])\\n #print(test_data[0])\\n\\n # build dataset\\n train_dataset = self.loader.build_dataset(\\n train_data, \\n self.args.train_max_seq_len)\\n train_loader = self.loader.build_dataloader(\\n train_dataset, 'train')\\n\\n test_dataset = self.loader.build_dataset(\\n test_data,\\n self.args.eval_max_seq_len)\\n test_loader = self.loader.build_dataloader(\\n test_dataset, 'test')\\n\\n if self.args.use_dev:\\n dev_dataset = self.loader.build_dataset(\\n dev_data,\\n self.args.eval_max_seq_len)\\n dev_loader = self.loader.build_dataloader(\\n dev_dataset, 'dev')\\n return train_loader, dev_loader, test_loader\\n else:\\n return train_loader, test_loader\",\n \"def test_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_test, **self.dl_kwargs)\",\n \"def train_dataloader(self) -> DataLoader:\\n return self._custom_data_loader()\",\n \"def train_dataloader(self):\\r\\n\\r\\n # transformation\\r\\n train_transform = Compose(\\r\\n [\\r\\n ApplyTransformToKey(\\r\\n key='video',\\r\\n transform=Compose(\\r\\n [\\r\\n UniformTemporalSubsample(8),\\r\\n Lambda(lambda x: x / 255.0),\\r\\n Normalize((0.45, 0.45, 0.45), (0.225, 0.225, 0.225)),\\r\\n RandomShortSideScale(min_size=256, max_size=320),\\r\\n RandomCrop(244),\\r\\n RandomHorizontalFlip(p=0.5),\\r\\n ]\\r\\n )\\r\\n )\\r\\n ]\\r\\n )\\r\\n\\r\\n train_dataset = pv.data.Kinetics(\\r\\n data_path=os.path.join(self._DATA_PATH, \\\"train\\\"),\\r\\n clip_sampler=pv.data.make_clip_sampler(\\\"random\\\", self._CLIP_DURATION),\\r\\n decode_audio=False,\\r\\n transform=train_transform\\r\\n )\\r\\n return torch.utils.data.DataLoader(\\r\\n train_dataset,\\r\\n batch_size=self._BATCH_SIZE,\\r\\n num_workers=self._NUM_WORKERS,\\r\\n )\",\n \"def train_dataloader(self) -> DataLoader:\\n return DataLoader(\\n self.train_dataset,\\n batch_size=self.hparams.batch_size,\\n shuffle=True,\\n num_workers=multiprocessing.cpu_count(),\\n )\",\n \"def val_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_valid, **self.dl_kwargs)\",\n \"def create_dataloader(data):\\r\\n input_ids = torch.LongTensor([sent['input_ids'] for sent in data])\\r\\n input_mask = torch.LongTensor([sent['input_mask'] for sent in data])\\r\\n segment_ids = torch.LongTensor([sent['segment_ids'] for sent in data])\\r\\n label_ids = torch.LongTensor([sent['label_ids'] for sent in data])\\r\\n\\r\\n dataset = TensorDataset(input_ids, input_mask, segment_ids, label_ids)\\r\\n\\r\\n train_sampler = RandomSampler(dataset)\\r\\n dataloader = DataLoader(dataset, sampler=train_sampler, batch_size=BATCH_SIZE)\\r\\n\\r\\n return dataloader\",\n \"def dataloader(self):\\n return DataLoader\",\n \"def dataloader_vatexEnglish_train(args, tokenizer):\\n\\n vatexEnglish_dataset = VATEXENGLISH_multi_sentence_dataLoader(\\n subset=\\\"train\\\",\\n data_path=args.data_path,\\n features_path=args.features_path,\\n max_words=args.max_words,\\n feature_framerate=args.feature_framerate,\\n tokenizer=tokenizer,\\n max_frames=args.max_frames,\\n )\\n\\n train_sampler = torch.utils.data.distributed.DistributedSampler(vatexEnglish_dataset)\\n\\n dataloader = DataLoader(\\n vatexEnglish_dataset,\\n batch_size=args.batch_size // args.n_gpu,\\n num_workers=args.num_thread_reader,\\n pin_memory=False,\\n shuffle=(train_sampler is None),\\n sampler=train_sampler,\\n drop_last=True,\\n )\\n\\n return dataloader, len(vatexEnglish_dataset), train_sampler\",\n \"def _get_dataloader(samples, batch_size):\\n print(\\\"Cogiendo dataloader\\\")\\n return DataLoader(samples, shuffle=True, batch_size=batch_size)\",\n \"def test_dataloader(self) -> data.DataLoader:\\n return data.DataLoader(dataset=self.datasets['test'], batch_size=self.batch_size,\\n num_workers=self.num_workers, shuffle=False, pin_memory=False)\",\n \"def create_train_dataloader(configs):\\n train_lidar_aug = OneOf([\\n Random_Rotation(limit_angle=np.pi / 4, p=1.0),\\n Random_Scaling(scaling_range=(0.95, 1.05), p=1.0),\\n ], p=0.66)\\n train_dataset = KittiDataset(configs, mode='train', lidar_aug=train_lidar_aug, hflip_prob=configs.hflip_prob,\\n num_samples=configs.num_samples)\\n train_sampler = None\\n if configs.distributed:\\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)\\n train_dataloader = DataLoader(train_dataset, batch_size=configs.batch_size, shuffle=(train_sampler is None),\\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=train_sampler)\\n\\n return train_dataloader, train_sampler\",\n \"def _init_train_loader(self):\\n # Choose the right dataset type\\n if self.config_args[\\\"num_members\\\"] > 1:\\n class_dataset_wrapper = dataset_wrapper.MixMoDataset\\n else:\\n class_dataset_wrapper = dataset_wrapper.MSDADataset\\n\\n # Load augmentations\\n self.traindatasetwrapper = class_dataset_wrapper(\\n dataset=self.train_dataset,\\n num_classes=int(self.config_args[\\\"data\\\"][\\\"num_classes\\\"]),\\n num_members=self.config_args[\\\"num_members\\\"],\\n dict_config=self.config_args[\\\"training\\\"][\\\"dataset_wrapper\\\"],\\n properties=self.properties\\n )\\n\\n # Build standard sampler\\n _train_sampler = torch.utils.data.sampler.RandomSampler(\\n data_source=self.traindatasetwrapper, ## only needed for its length\\n num_samples=None,\\n replacement=False,\\n )\\n\\n # Wrap it with the repeating sampler used for multi-input models\\n batch_sampler = batch_repetition_sampler.BatchRepetitionSampler(\\n sampler=_train_sampler,\\n batch_size=self.batch_size,\\n num_members=self.config_args[\\\"num_members\\\"],\\n drop_last=True,\\n config_batch_sampler=self.config_args[\\\"training\\\"][\\\"batch_sampler\\\"]\\n )\\n\\n self.train_loader = torch.utils.data.DataLoader(\\n self.traindatasetwrapper,\\n batch_sampler=batch_sampler,\\n num_workers=self.num_workers,\\n batch_size=1,\\n shuffle=False,\\n sampler=None,\\n drop_last=False,\\n pin_memory=True,\\n )\",\n \"def prepare_dataloader(opt, dataobj):\\n\\n def load_data(name):\\n with open(name, 'rb') as f:\\n data = pickle.load(f)\\n num_types = 1 # There is no event type prediction, hence using a dummy value, this will basically be a constant value field\\n return data, num_types\\n\\n print('[Info] Loading train data...')\\n train_data, num_types = load_data(opt.data + 'train_ny.pkl')\\n print('[Info] Loading dev data...')\\n val_data, _ = load_data(opt.data + 'val_ny.pkl')\\n print('[Info] Loading test data...')\\n test_data, _ = load_data(opt.data + 'test_ny.pkl')\\n\\n trainloader = get_dataloader(train_data, opt.batch_size, shuffle=True)\\n validationloader = get_dataloader(val_data, opt.batch_size, shuffle=True)\\n testloader = get_dataloader(test_data, opt.batch_size, shuffle=False)\\n return trainloader, validationloader, testloader, num_types\",\n \"def dataloader_msvd_train(args, tokenizer):\\n\\n msvd_dataset = MSVD_multi_sentence_dataLoader(\\n subset=\\\"train\\\",\\n data_path=args.data_path,\\n features_path=args.features_path,\\n max_words=args.max_words,\\n feature_framerate=args.feature_framerate,\\n tokenizer=tokenizer,\\n max_frames=args.max_frames,\\n )\\n\\n train_sampler = torch.utils.data.distributed.DistributedSampler(msvd_dataset)\\n\\n dataloader = DataLoader(\\n msvd_dataset,\\n batch_size=args.batch_size // args.n_gpu,\\n num_workers=args.num_thread_reader,\\n pin_memory=False,\\n shuffle=(train_sampler is None),\\n sampler=train_sampler,\\n drop_last=True,\\n )\\n\\n return dataloader, len(msvd_dataset), train_sampler\",\n \"def test_dataloader(self) -> DataLoader:\\n return DataLoader(\\n self.test_dataset,\\n batch_size=self.hparams.batch_size,\\n shuffle=False,\\n num_workers=multiprocessing.cpu_count(),\\n )\",\n \"def build_dataloader(bs, shfle):\\n # change get_labels to correct version (classification vs regression)\\n dataset = TensorDataset(rand_data(), get_labels())\\n dataset = TensorDataset(rand_data(), get_regression_labels())\\n\\n return DataLoader(dataset, batch_size=bs, shuffle=shfle, num_workers=0)\",\n \"def data_loader(data, train=True):\\n\\n loader_config = {\\n 'batch_size':64,\\n 'shuffle':train\\n }\\n \\n return torch.utils.data.DataLoader(data, **loader_config)\",\n \"def get_dataloaders(logging, batch_size):\\n # Load Data\\n logging.info(\\\"Reading Train and Test data...\\\")\\n train_df = pd.read_csv(\\\"C:/tmp/avila_classification/data/avila-tr.txt\\\", header=None)\\n test_df = pd.read_csv(\\\"C:/tmp/avila_classification/data/avila-ts.txt\\\", header=None)\\n\\n # Fix column names\\n col_names = ['col_' + str(j + 1) for j in range(train_df.shape[1] - 1)]\\n indep_cols = col_names.copy()\\n col_names.append('y')\\n\\n logging.debug(\\\"Assigning columns\\\")\\n train_df.columns = col_names\\n test_df.columns = col_names\\n\\n # Encode dependent variable column\\n le = LabelEncoder()\\n le.fit(train_df['y'])\\n logging.debug(f\\\"Classes: {le.classes_}\\\")\\n logging.debug(f\\\"Transformed Classes: {le.transform(le.classes_)}\\\")\\n\\n train_df['y_enc'] = le.transform(train_df['y'])\\n test_df['y_enc'] = le.transform(test_df['y'])\\n\\n # train_df.head()\\n logging.debug(f\\\"Shape of train data: {train_df.shape}\\\")\\n logging.debug(f\\\"Shape of test data: {test_df.shape}\\\")\\n\\n # Create train and validation dataloaders\\n train_ds = AvilaDataset(data_frame=train_df, indep_cols=indep_cols, dep_col='y_enc')\\n valid_ds = AvilaDataset(data_frame=test_df, indep_cols=indep_cols, dep_col='y_enc')\\n\\n # Should be some exponent of 2 (128, 256)\\n # batch_size = 256\\n train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\\n valid_dl = DataLoader(valid_ds, batch_size=batch_size, shuffle=False)\\n\\n return train_dl, valid_dl, le\",\n \"def train_dataloader(self) -> data.DataLoader:\\n # Random weighted sampler to approach the imbalanced dataset\\n self.weights = [1.0 / i for i in self.weights]\\n\\n _sample_weights = [0] * len(self.datasets['train'])\\n\\n for idx, (_, label) in enumerate(self.datasets['train']):\\n _weight = self.weights[label]\\n _sample_weights[idx] = _weight\\n\\n random_sampler = data.WeightedRandomSampler(_sample_weights,\\n len(self.datasets['train']), replacement=False)\\n\\n return data.DataLoader(dataset=self.datasets['train'], batch_size=self.batch_size,\\n num_workers=self.num_workers, pin_memory=False,\\n sampler=random_sampler)\",\n \"def get_loader(split):\\n assert split in ['train', 'val', 'trainval', 'test']\\n image_feature_path = config.rcnn_trainval_path if split != 'test' else config.rcnn_test_path\\n dataset = VQAFeatureDataset(\\n split,\\n image_feature_path,\\n )\\n loader = torch.utils.data.DataLoader(\\n dataset,\\n batch_size=512,\\n shuffle=True if split not in ['val', 'test'] else False, # only shuffle the data in training\\n pin_memory=True,\\n num_workers=config.workers,\\n )\\n return loader\",\n \"def get_dataloader(dataset, datadir, train_bs, test_bs, dataidxs=None, noise_level=0, net_id=None, total=0):\\n if dataset in ('mnist', 'femnist', 'fmnist', 'cifar10','cifar100', 'svhn', 'generated', 'covtype', 'a9a', 'rcv1', 'SUSY','tinyimagenet'):\\n if dataset == 'mnist':\\n dl_obj = MNIST_truncated\\n\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n elif dataset == 'femnist':\\n dl_obj = FEMNIST\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n elif dataset == 'fmnist':\\n dl_obj = FashionMNIST_truncated\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n elif dataset == 'svhn':\\n dl_obj = SVHN_custom\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n\\n elif dataset == 'cifar10':\\n dl_obj = CIFAR10_truncated\\n\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Lambda(lambda x: F.pad(\\n Variable(x.unsqueeze(0), requires_grad=False),\\n (4, 4, 4, 4), mode='reflect').data.squeeze()),\\n transforms.ToPILImage(),\\n transforms.RandomCrop(32),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)\\n ])\\n # data prep for test set\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n \\n elif dataset == 'cifar100':\\n dl_obj = CIFAR100_truncated\\n\\n normalize = transforms.Normalize(mean=[0.5070751592371323, 0.48654887331495095, 0.4409178433670343],\\n std=[0.2673342858792401, 0.2564384629170883, 0.27615047132568404])\\n # transform_train = transforms.Compose([\\n # transforms.RandomCrop(32),\\n # transforms.RandomHorizontalFlip(),\\n # transforms.ToTensor(),\\n # normalize\\n # ])\\n transform_train = transforms.Compose([\\n # transforms.ToPILImage(),\\n transforms.RandomCrop(32, padding=4),\\n transforms.RandomHorizontalFlip(),\\n transforms.RandomRotation(15),\\n transforms.ToTensor(),\\n normalize\\n ])\\n # data prep for test set\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n normalize])\\n\\n elif dataset == 'tinyimagenet': \\n # random_ids = np.random.randint(1000, size=datasize)\\n # train_indices = random_ids\\n\\n imagenet_mean = [0.485, 0.456, 0.406]\\n imagenet_std = [0.229, 0.224, 0.225]\\n\\n train_dl = torch.utils.data.DataLoader(\\n torchvision.datasets.ImageFolder(datadir +\\\"/train\\\",\\n transform=transforms.Compose([\\n transforms.Resize(32), \\n transforms.ToTensor(),\\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\\n #Phuong 09/26 drop_last=False -> True\\n batch_size=train_bs, drop_last=True)\\n \\n test_dl = torch.utils.data.DataLoader(\\n torchvision.datasets.ImageFolder(datadir +\\\"/test\\\",\\n transform=transforms.Compose([\\n transforms.Resize(32), \\n transforms.ToTensor(),\\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\\n #Phuong 09/26 drop_last=False -> True\\n batch_size=test_bs, drop_last=True)\\n\\n return train_dl, test_dl, None, None\\n\\n\\n else:\\n dl_obj = Generated\\n transform_train = None\\n transform_test = None\\n\\n\\n train_ds = dl_obj(datadir, dataidxs=dataidxs, train=True, transform=transform_train, download=True)\\n test_ds = dl_obj(datadir, train=False, transform=transform_test, download=True)\\n\\n train_dl = data.DataLoader(dataset=train_ds, batch_size=train_bs, shuffle=True, drop_last= dataset in ['cifar100'])\\n test_dl = data.DataLoader(dataset=test_ds, batch_size=test_bs, shuffle=False, drop_last=False)\\n\\n return train_dl, test_dl, train_ds, test_ds\",\n \"def __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\",\n \"def get_dataloader(self):\\n shuffle = True if self.mode == \\\"train\\\" else False\\n return DataLoader(self.get_dataset(), batch_size=self.batch_size, shuffle = shuffle, \\n collate_fn=create_mini_batch)\",\n \"def dataloaders():\\n # train data path\\n data_train = '../dataset/train/'\\n # set transformations\\n train_transforms = transforms.Compose([\\n transforms.Resize((224, 224)),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406],\\n [0.229, 0.224, 0.225])])\\n \\n train_data = datasets.ImageFolder(data_train, transform = train_transforms)\\n trainloader = torch.utils.data.DataLoader(train_data, batch_size = 16, shuffle = True)\\n \\n return trainloader\",\n \"def get_data_loader(batch_size=10, num_workers=2):\\n \\n data_loader = torch.utils.data.DataLoader(dataset=TempuckeyDataSet(),\\n batch_size=batch_size,\\n shuffle=True,\\n pin_memory=True,\\n num_workers=num_workers,\\n collate_fn=collate)\\n return data_loader\",\n \"def get_dataloader(dataset, batchsize):\\n\\n train_set_size = int(0.8 * dataset.__len__())\\n train_indices = np.random.choice(np.arange(dataset.__len__()),\\n train_set_size, replace=False)\\n train_sampler = SubsetRandomSampler(train_indices)\\n\\n val_indices = np.setdiff1d(np.arange(dataset.__len__()),\\n train_indices, assume_unique=True)\\n val_sampler = SubsetRandomSampler(val_indices)\\n\\n trainloader = DataLoader(dataset, batch_size=batchsize,\\n sampler=train_sampler, num_workers=2)\\n valloader = DataLoader(dataset, batch_size=batchsize,\\n sampler=val_sampler, num_workers=2)\\n\\n return trainloader, valloader\",\n \"def data_loader(root, batch_size=64):\\n input_transform = get_transform()\\n dataset = CustomDataset(root, input_transform)\\n return data.DataLoader(dataset=dataset,\\n batch_size=batch_size,\\n shuffle=False)\",\n \"def get_train_loader(batch_size, train_set, train_sampler):\\n train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, sampler=train_sampler, num_workers=4)\\n\\n return train_loader\",\n \"def _custom_data_loader(self) -> DataLoader:\\n dataloaders = DataLoader(self.dataset, batch_size=1)\\n return dataloaders\",\n \"def get_loader(data, json, batch_size, shuffle, num_workers):\\n dataset = FinNumDataset(data, json)\\n\\n data_loader = torch.utils.data.DataLoader(dataset=dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n num_workers=num_workers,\\n collate_fn=collate_fn)\\n return data_loader\",\n \"def test_dataloader(self) -> DataLoader:\\n return self._custom_data_loader()\",\n \"def build_training_data_loader(self) -> DataLoader:\\n pass\",\n \"def data_loader(\\n self, batch_size: int = 1, iter_steps: int = 0, batch_as_list: bool = True\\n ) -> DataLoader:\\n data = self.data\\n datasets = []\\n\\n for _, dat in data.items():\\n datasets.append(dat.dataset())\\n\\n if len(datasets) < 1:\\n raise FileNotFoundError(\\n \\\"no datasets available for this model to create a loader from\\\"\\n )\\n\\n return DataLoader(\\n *datasets,\\n batch_size=batch_size,\\n iter_steps=iter_steps,\\n batch_as_list=batch_as_list,\\n )\",\n \"def get_data_loaders(args, tokenizer):\\n personachat = get_dataset(tokenizer, args.dataset_path, args.dataset_cache, args.train_lang)\\n _ = personachat.pop(\\\"test\\\", None)\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": [], \\\"valid\\\": []}\\n\\n if args.train_lang in [\\\"En\\\", \\\"Fr\\\", \\\"It\\\", \\\"Id\\\", \\\"Jp\\\", \\\"Ko\\\", \\\"Zh\\\"]: #monolingual data\\n for dataset_name, dataset in personachat.items():\\n for dial in dataset[args.train_lang]: #dial: {\\\"persona\\\":[], \\\"history\\\":[], \\\"response\\\":str}\\n instance = build_input_from_segments(dial[\\\"persona\\\"], dial[\\\"history\\\"][-args.max_turns:], dial[\\\"response\\\"], tokenizer, lm_labels = True)\\n datasets[dataset_name].append(instance) \\n else: #multilingual data\\n for dataset_name, dataset in personachat.items():\\n for lang, dials in dataset.items():\\n for dial in dials: #dial: {\\\"persona\\\":[], \\\"history\\\":[], \\\"response\\\":str}\\n instance = build_input_from_segments(dial[\\\"persona\\\"], dial[\\\"history\\\"][-args.max_turns:], dial[\\\"response\\\"], tokenizer, lang_id=\\\"<{}>\\\".format(lang.lower()), lm_labels = True)\\n datasets[dataset_name].append(instance) #all langs together\\n\\n\\n logger.info(\\\"Build train and validation dataloaders\\\")\\n train_dataset = DatasetTrain(datasets[\\\"train\\\"])\\n valid_dataset = DatasetTrain(datasets[\\\"valid\\\"])\\n\\n #logger.info(\\\"Build train and validation dataloaders\\\")\\n #train_dataset, valid_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"]), TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) if args.distributed else None\\n valid_sampler = torch.utils.data.distributed.DistributedSampler(valid_dataset) if args.distributed else None\\n train_loader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size, shuffle=(not args.distributed), collate_fn=collate_fn)\\n valid_loader = DataLoader(valid_dataset, sampler=valid_sampler, batch_size=args.valid_batch_size, shuffle=False, collate_fn=collate_fn)\\n\\n # logger.info(\\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(train_dataset.tensors[0].shape))\\n # #logger.info(\\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(train_dataset.tensors[1].shape))\\n # logger.info(\\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(valid_dataset.tensors[0].shape))\\n logger.info(\\\"Train dataset length: {}\\\".format(len(train_dataset)))\\n logger.info(\\\"Valid dataset length: {}\\\".format(len(valid_dataset)))\\n return train_loader, valid_loader, train_sampler, valid_sampler\",\n \"def _init_al_dataset(self):\\n\\n self._init_dataset()\\n\\n train_dataset = self.datasets['train']\\n\\n dataset_size = len(train_dataset)\\n self.budget = math.ceil(self.budget_frac*dataset_size)\\n Sampler.__init__(self, config, self.budget) # TODO: Weird place to initialise this\\n\\n all_indices = set(np.arange(dataset_size))\\n k_initial = math.ceil(len(all_indices)*self.initial_budget_frac)\\n initial_indices = random.sample(list(all_indices), k=k_initial)\\n\\n sampler_init = data.sampler.SubsetRandomSampler(initial_indices) # need to sample from training dataset\\n\\n self.labelled_dataloader = data.DataLoader(train_dataset, sampler=sampler_init, batch_size=self.batch_size, drop_last=True)\\n self.val_dataloader = data.DataLoader(self.datasets['valid'], batch_size=self.batch_size, drop_last=False)\\n self.test_dataloader = data.DataLoader(self.datasets['test'], batch_size=self.batch_size, drop_last=False)\\n\\n return all_indices, initial_indices\",\n \"def get_dataloaders(args):\\n if args.dataset == 'heat':\\n dataset_class = heat.HeatDiffusionDataset\\n else:\\n raise ValueError(f'Unknown dataset {args.dataset}')\\n train_dataset = dataset_class(\\n dataset_class.get_train_path(args.data_path), args, train=True)\\n if args.dist:\\n train_sampler = torch.utils.data.distributed.DistributedSampler(\\n train_dataset)\\n else:\\n train_sampler = torch.utils.data.RandomSampler(train_dataset)\\n train_loader = torch.utils.data.DataLoader(\\n train_dataset, batch_size=args.batch_size, num_workers=args.workers,\\n sampler=train_sampler, pin_memory=True, drop_last=args.drop_last)\\n if not args.no_eval:\\n validation_dataset = dataset_class(\\n dataset_class.get_validation_path(args.data_path), args, train=False)\\n if args.dist:\\n validation_sampler = torch.utils.data.distributed.DistributedSampler(\\n validation_dataset, shuffle=False)\\n else:\\n validation_sampler = torch.utils.data.SequentialSampler(\\n validation_dataset)\\n validation_loader = torch.utils.data.DataLoader(\\n validation_dataset, batch_size=args.batch_size,\\n num_workers=args.workers, sampler=validation_sampler,\\n pin_memory=True, drop_last=args.drop_last)\\n\\n test_dataset = dataset_class(\\n dataset_class.get_test_path(args.data_path), args, train=False)\\n if args.dist:\\n test_sampler = torch.utils.data.distributed.DistributedSampler(\\n test_dataset, shuffle=False)\\n else:\\n test_sampler = torch.utils.data.SequentialSampler(\\n test_dataset)\\n test_loader = torch.utils.data.DataLoader(\\n test_dataset, batch_size=args.batch_size,\\n num_workers=args.workers, sampler=test_sampler,\\n pin_memory=True, drop_last=args.drop_last)\\n else:\\n validation_loader = None\\n test_loader = None\\n\\n # Update the data shape if needed.\\n if args.data_shape is None:\\n args.data_shape = train_dataset.get_shape()\\n if args.data_target_shape is None:\\n args.data_target_shape = train_dataset.get_target_shape()\\n\\n return train_loader, validation_loader, test_loader\",\n \"def create_dataset_sampler_loader(file_path, cuda, batch_size, hvd):\\n # When supported, use 'forkserver' to spawn dataloader workers\\n # instead of 'fork' to prevent issues with Infiniband implementations\\n # that are not fork-safe.\\n kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}\\n if (kwargs.get('num_workers', 0) > 0 and hasattr(mp, '_supports_context')\\n and 'forkserver' in mp.get_all_start_methods()):\\n kwargs['multiprocessing_context'] = 'forkserver'\\n\\n # create dataset\\n dataset = MNISTDataset(file_path)\\n # Horovod: use DistributedSampler to partition the training data\\n sampler = Data.distributed.DistributedSampler(\\n dataset, num_replicas=hvd.size(), rank=hvd.rank())\\n loader = torch.utils.data.DataLoader(\\n dataset, batch_size=batch_size, sampler=sampler, **kwargs)\\n return dataset, sampler, loader\",\n \"def to_DataLoader(self, **kwargs):\\r\\n return DataLoader(self, **kwargs)\",\n \"def data_creator(config):\\n train_dataset, val_dataset = LinearDataset(2, 5), LinearDataset(2, 5)\\n train_loader = DataLoader(train_dataset, batch_size=config[\\\"batch_size\\\"])\\n val_loader = DataLoader(val_dataset, batch_size=config[\\\"batch_size\\\"])\\n return train_loader, val_loader\",\n \"def make_dataloaders(params):\\r\\n transform_train = transforms.Compose([transforms.RandomCrop(32, padding=4),\\r\\n transforms.RandomHorizontalFlip(),\\r\\n transforms.ToTensor(),\\r\\n transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])])\\r\\n\\r\\n transform_validation = transforms.Compose([transforms.ToTensor(),\\r\\n transforms.Normalize([0.4914, 0.4822, 0.4465],\\r\\n [0.2023, 0.1994, 0.2010])])\\r\\n\\r\\n transform_validation = transforms.Compose([transforms.ToTensor()])\\r\\n\\r\\n trainset = torchvision.datasets.CIFAR10(root=params['path'], train=True, transform=transform_train)\\r\\n testset = torchvision.datasets.CIFAR10(root=params['path'], train=False, transform=transform_validation)\\r\\n\\r\\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=params['batch_size'], shuffle=True, num_workers=4)\\r\\n testloader = torch.utils.data.DataLoader(testset, batch_size=params['batch_size'], shuffle=False, num_workers=4)\\r\\n return trainloader, testloader\",\n \"def load_data(batch_size=batch_size):\\n trainset = LibriSpeechDataset(training_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds))\\n testset = LibriSpeechDataset(validation_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds), stochastic=False)\\n\\n train_loader = DataLoader(trainset, batch_size=batch_size, num_workers=1, shuffle=True, drop_last=True)\\n test_loader = DataLoader(testset, batch_size=1, num_workers=1, drop_last=True)\\n\\n return train_loader, test_loader\",\n \"def initialize_dataloaders(\\n self, X: Union[np.ndarray, pd.DataFrame], y: Union[np.ndarray, np.array]\\n ):\\n training_design_matrix, training_targets_array, validation_design_matrix, validation_targets_array = self.generate_training_validation_split(\\n X, y\\n )\\n training_dataloader_kwargs = {\\n \\\"design_matrix\\\": training_design_matrix,\\n \\\"targets_array\\\": training_targets_array,\\n \\\"data_type\\\": self.data_type,\\n \\\"batch_size\\\": self.batch_size,\\n \\\"shuffle\\\": self.shuffle_training_examples,\\n }\\n validation_dataloader_kwargs = {\\n \\\"design_matrix\\\": validation_design_matrix,\\n \\\"targets_array\\\": validation_targets_array,\\n \\\"data_type\\\": self.data_type,\\n \\\"batch_size\\\": self.batch_size,\\n \\\"shuffle\\\": False,\\n }\\n self.training_dataloader = self.generate_dataloader(**training_dataloader_kwargs)\\n self.validation_dataloader = self.generate_dataloader(**validation_dataloader_kwargs)\",\n \"def get_dataloaders(data_dir,train_batch_size,val_batch_size,aug_flag):\\n # Create the dataset object.\\n transformed_dataset = PersonDataset(data_dir,False)\\n # dataloader for train and validation\\n validation_split = 0.2\\n shuffle_dataset = True\\n #random seed to keep the train-val split constant for inference purpose\\n random_seed= 42\\n # create indices for training and validation splits.\\n dataset_size = len(transformed_dataset)\\n # we create the indices using python range function and store it into a list\\n indices = list(range(dataset_size))\\n split = int(np.floor(validation_split*dataset_size))\\n if shuffle_dataset:\\n np.random.seed(random_seed)\\n np.random.shuffle(indices)\\n train_indices,val_indices = indices[split:],indices[:split]\\n # create dataloaders...\\n train_sampler = SubsetRandomSampler(train_indices)\\n val_sampler = SubsetRandomSampler(val_indices)\\n train_aug,val_aug = aug_flag,False\\n train_loader = DataLoader(PersonDataset(data_dir,train_aug), batch_size=train_batch_size, shuffle=False, num_workers=0,sampler = train_sampler)\\n val_loader = DataLoader(PersonDataset(data_dir,val_aug), batch_size=val_batch_size, shuffle=False, num_workers=0,sampler = val_sampler)\\n\\n # dictionary for data loaders..\\n dataloaders = {\\\"train\\\" :train_loader,\\n \\\"val\\\":val_loader\\n }\\n return dataloaders\",\n \"def torch_dataset_loader(dataset, batch_size, shuffle, kwargs):\\n loader = DataLoader(TorchData(dataset),\\n batch_size=batch_size,\\n shuffle=shuffle,\\n **kwargs)\\n return loader\",\n \"def get_dataloader(data_folder, model_name, data_name, size=\\\"default\\\"):\\n training_set = None\\n validation_set = None\\n\\n if model_name == \\\"Howe_Patterson\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\\n\\n elif size == \\\"small\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\\n elif size == \\\"tiny\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\\n\\n\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_full_SHHS(partition['train'], data_folder)\\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_full(partition['train'], data_folder)\\n validation_set = Dataset_full(partition['validation'], data_folder)\\n elif data_name == \\\"philips\\\":\\n training_set = Dataset_Philips_full(partition['train'], data_folder)\\n validation_set = Dataset_Philips_full(partition['validation'], data_folder)\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n training_set = ConcatDataset(\\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n validation_set = ConcatDataset(\\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n elif model_name == \\\"Deep_Sleep\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\\n\\n elif size == \\\"small\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\\n elif size == \\\"tiny\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\\n\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_full_SHHS(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_full(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_full(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"philips\\\":\\n training_set = Dataset_Philips_full(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_Philips_full(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n # TODO combined dataset https://discuss.pytorch.org/t/train-simultaneously-on-two-datasets/649/17\\n training_set = ConcatDataset(\\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n validation_set = ConcatDataset(\\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n elif model_name == \\\"ConvNet_IID\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition_IID_windows.pkl')))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition_IID_windows.pkl'))\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_IID_window_SHHS(partition['train'], data_folder)\\n validation_set = Dataset_IID_window_SHHS(partition['validation'], data_folder)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_IID_window(partition['train'], data_folder)\\n validation_set = Dataset_IID_window(partition['validation'], data_folder)\\n elif data_name == \\\"philips\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n training_set = ConcatDataset(\\n Dataset_IID_window(partition[0]['train'], data_folder[0]),\\n Dataset_IID_window_SHHS(partition[1]['train'], data_folder[1]))\\n validation_set = ConcatDataset(\\n Dataset_IID_window(partition[0]['validation'], data_folder[0]),\\n Dataset_IID_window_SHHS(partition[1]['validation'], data_folder[1]))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n\\n else:\\n print(\\\"{} wrong model for dataloader\\\".format(model_name))\\n exit()\\n\\n return training_set, validation_set\",\n \"def get_loader(\\n data_source: Iterable[dict],\\n open_fn: Callable,\\n dict_transform: Callable = None,\\n sampler=None,\\n collate_fn: Callable = default_collate_fn,\\n batch_size: int = 32,\\n num_workers: int = 4,\\n shuffle: bool = False,\\n drop_last: bool = False,\\n):\\n from catalyst.data.dataset import ListDataset\\n\\n dataset = ListDataset(\\n list_data=data_source, open_fn=open_fn, dict_transform=dict_transform,\\n )\\n loader = torch.utils.data.DataLoader(\\n dataset=dataset,\\n sampler=sampler,\\n collate_fn=collate_fn,\\n batch_size=batch_size,\\n num_workers=num_workers,\\n shuffle=shuffle,\\n pin_memory=torch.cuda.is_available(),\\n drop_last=drop_last,\\n )\\n return loader\",\n \"def val_dataloader(self):\\r\\n val_dataset = pv.data.Kinetics(\\r\\n data_path=os.path.join(self._DATA_PATH, \\\"val\\\"),\\r\\n clip_sampler=pv.data.make_clip_sampler(\\\"uniform\\\", self._CLIP_DURATION),\\r\\n decode_audio=False,\\r\\n )\\r\\n return torch.utils.data.DataLoader(\\r\\n val_dataset,\\r\\n batch_size=self._BATCH_SIZE,\\r\\n num_workers=self._NUM_WORKERS,\\r\\n )\",\n \"def create_dataloaders(data_dir):\\n\\n trng_dataset = datasets.ImageFolder(data_dir / TRNG_FOLDER,\\n transform=flowernet.trng_transform)\\n trng_dataloader = torch.utils.data.DataLoader(trng_dataset,\\n batch_size=64,\\n shuffle=True)\\n\\n valn_dataset = datasets.ImageFolder(data_dir / VALN_FOLDER,\\n transform=flowernet.pred_transform)\\n valn_dataloader = torch.utils.data.DataLoader(valn_dataset,\\n batch_size=64,\\n shuffle=True)\\n\\n return trng_dataloader, valn_dataloader\",\n \"def loadData(self):\\n batch_size = 256\\n \\n #if self.conv_sg == True:\\n # batch_size = 1 \\n \\n download = True\\n root = self.root + self.dataset\\n if self.dataset == \\\"MNIST\\\": \\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])\\n trainset = torchvision.datasets.MNIST(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.MNIST(root, train=False, download=download, transform=transform)\\n \\n if self.dataset == \\\"CIFAR10\\\":\\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465,), (0.2023, 0.1994, 0.2010,))])\\n trainset = torchvision.datasets.CIFAR10(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.CIFAR10(root, train=False, download=download, transform=transform)\\n \\n if self.dataset == \\\"CIFAR100\\\":\\n transform = transforms.Compose([transforms.ToTensor()])\\n trainset = torchvision.datasets.CIFAR100(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.CIFAR100(root, train=False, download=download, transform=transform)\\n \\n \\n trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size,\\n shuffle=False, num_workers=0, pin_memory = False)\\n \\n testloader = torch.utils.data.DataLoader(testset, batch_size= batch_size,\\n shuffle=False, num_workers=2, pin_memory = False)\\n \\n return trainloader, testloader\",\n \"def train_dataloader(self, batch_size: Optional[int] = None) -> DataLoader:\\n dataset = TabularDataset(\\n task=self.config.task,\\n data=self.train,\\n categorical_cols=self.config.categorical_cols,\\n continuous_cols=self.config.continuous_cols,\\n embed_categorical=(not self.do_leave_one_out_encoder()),\\n target=self.target,\\n )\\n return DataLoader(\\n dataset,\\n batch_size if batch_size is not None else self.batch_size,\\n shuffle=True if self.train_sampler is None else False,\\n num_workers=self.config.num_workers,\\n sampler=self.train_sampler,\\n pin_memory=self.config.pin_memory,\\n )\",\n \"def create_val_dataloader(configs, mode):\\n val_sampler = None\\n val_dataset = KittiDataset(configs, mode=mode, lidar_aug=None, hflip_prob=0., num_samples=configs.num_samples)\\n if configs.distributed:\\n val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset, shuffle=False)\\n val_dataloader = DataLoader(val_dataset, batch_size=configs.batch_size, shuffle=False,\\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=val_sampler)\\n\\n return val_dataloader\",\n \"def load_dataset():\\n\\n\\n train_dd_loader = DailyDialogLoader(PATH_TO_TRAIN_DATA, load=False)\\n train_dataloader = DataLoader(train_dd_loader, batch_size=16, shuffle=True, num_workers=0,\\n collate_fn=PadCollate())\\n\\n test_dd_loader = DailyDialogLoader(PATH_TO_TEST_DATA, load=True)\\n test_dataloader = DataLoader(test_dd_loader, batch_size=1, shuffle=False, num_workers=0,\\n collate_fn=PadCollate())\\n\\n assert train_dd_loader.vocabulary.n_words == test_dd_loader.vocabulary.n_words\\n\\n return train_dd_loader, train_dataloader, test_dataloader\",\n \"def val_dataloader(self) -> DataLoader:\\n return DataLoader(\\n self.valid_dataset,\\n batch_size=self.hparams.batch_size,\\n shuffle=False,\\n num_workers=multiprocessing.cpu_count(),\\n )\",\n \"def dataloader_msrvtt_train(args, tokenizer):\\n\\n msrvtt_train_set = MSRVTT_multi_sentence_dataLoader(\\n csv_path=args.train_csv,\\n json_path=args.data_path,\\n features_path=args.features_path,\\n max_words=args.max_words,\\n feature_framerate=args.feature_framerate,\\n tokenizer=tokenizer,\\n max_frames=args.max_frames,\\n )\\n\\n train_sampler = torch.utils.data.distributed.DistributedSampler(msrvtt_train_set)\\n\\n dataloader = DataLoader(\\n msrvtt_train_set,\\n batch_size=args.batch_size // args.n_gpu,\\n num_workers=args.num_thread_reader,\\n pin_memory=False,\\n shuffle=(train_sampler is None),\\n sampler=train_sampler,\\n drop_last=True,\\n )\\n\\n return dataloader, len(msrvtt_train_set), train_sampler\",\n \"def load_dataloaders(args):\\n logger.info(\\\"Loading dataloaders...\\\")\\n p_path = os.path.join(\\\"./data/\\\", \\\"df_unencoded.pkl\\\")\\n train_path = os.path.join(\\\"./data/\\\", \\\"df_encoded.pkl\\\")\\n if (not os.path.isfile(p_path)) and (not os.path.isfile(train_path)):\\n df = get_data(args, load_extracted=False)\\n elif os.path.isfile(p_path) and (not os.path.isfile(train_path)):\\n df = get_data(args, load_extracted=True)\\n elif os.path.isfile(train_path):\\n df = load_pickle(\\\"df_encoded.pkl\\\")\\n \\n # Train-Test split\\n msk = np.random.rand(len(df)) < args.train_test_ratio\\n trainset = df[msk]\\n testset = df[~msk]\\n \\n trainset = text_dataset(trainset, args)\\n max_features_length = trainset.max_x_len\\n max_seq_len = trainset.max_y_len\\n train_length = len(trainset)\\n train_loader = DataLoader(trainset, batch_size=args.batch_size, shuffle=True,\\\\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\\n \\n testset = text_dataset(testset, args)\\n test_length = len(testset)\\n test_loader = DataLoader(testset, batch_size=args.batch_size, shuffle=True,\\\\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\\n return train_loader, train_length, max_features_length, max_seq_len, test_loader, test_length\",\n \"def val_dataloader(self) -> data.DataLoader:\\n return data.DataLoader(dataset=self.datasets['valid'], batch_size=self.batch_size,\\n num_workers=self.num_workers, shuffle=False, pin_memory=False)\",\n \"def create_test_dataloader(configs):\\n\\n test_dataset = KittiDataset(configs, mode='test', lidar_aug=None, hflip_prob=0., num_samples=configs.num_samples)\\n test_sampler = None\\n if configs.distributed:\\n test_sampler = torch.utils.data.distributed.DistributedSampler(test_dataset)\\n test_dataloader = DataLoader(test_dataset, batch_size=configs.batch_size, shuffle=False,\\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=test_sampler)\\n\\n return test_dataloader\",\n \"def creates_data_loader():\\n dataset_faces = FaceDataset(\\n IMG_DIR, transform=transform_train, face=True)\\n\\n dataset_no_faces = FaceDataset(\\n IMG_DIR, transform=transform_train, face=False)\\n\\n datasets_faces_split = train_val_test(dataset_faces, 0.2, 0.0)\\n datasets_no_faces_split = train_val_test(dataset_no_faces, 0.2, 0.0)\\n\\n datasets = {}\\n datasets[\\\"train\\\"] = datasets_faces_split[\\\"train\\\"] + \\\\\\n datasets_no_faces_split[\\\"train\\\"]\\n datasets[\\\"test\\\"] = datasets_no_faces_split[\\\"test\\\"]\\n datasets[\\\"val\\\"] = datasets_faces_split[\\\"val\\\"] + \\\\\\n datasets_no_faces_split[\\\"val\\\"]\\n\\n train_loader = DataLoader(dataset=datasets[\\\"train\\\"], batch_size=BATCH_SIZE,\\n num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False)\\n\\n val_loader = DataLoader(dataset=datasets[\\\"val\\\"], batch_size=BATCH_SIZE,\\n num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False)\\n return train_loader, val_loader\",\n \"def get_loader(dataset='train.txt', crop_size=128, image_size=28, batch_size=2, mode='train', num_workers=1): \\n transform = [] \\n if mode == 'train': \\n transform.append(transforms.RandomHorizontalFlip()) \\n transform.append(transforms.CenterCrop(crop_size)) \\n transform.append(transforms.Resize(image_size)) \\n transform.append(transforms.ToTensor()) \\n transform.append(transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) \\n transform = transforms.Compose(transform) \\n train_data=MyDataset(txt=dataset, transform=transform) \\n data_loader = DataLoader(dataset=train_data, \\n batch_size=batch_size, \\n shuffle=(mode=='train'), \\n num_workers=num_workers) \\n return data_loader\",\n \"def get_loader(data_list, config, train=True):\\n \\n with open(config[\\\"label_map\\\"], \\\"r\\\") as f:\\n label_map = json.load(f)\\n\\n dataset = GoogleSpeechDataset(\\n data_list=data_list,\\n label_map=label_map,\\n audio_settings=config[\\\"hparams\\\"][\\\"audio\\\"],\\n aug_settings=config[\\\"hparams\\\"][\\\"augment\\\"] if train else None,\\n cache=config[\\\"exp\\\"][\\\"cache\\\"]\\n )\\n\\n dataloader = DataLoader(\\n dataset,\\n batch_size=config[\\\"hparams\\\"][\\\"batch_size\\\"],\\n num_workers=config[\\\"exp\\\"][\\\"n_workers\\\"],\\n pin_memory=config[\\\"exp\\\"][\\\"pin_memory\\\"],\\n shuffle=True if train else False\\n )\\n\\n return dataloader\",\n \"def prepare_anndata(anndata, batch_size, shuffle=False):\\n # Add shuffling here\\n if sparse.issparse(anndata.X):\\n data = anndata.X.A\\n else:\\n data = anndata.X\\n data = torch.Tensor(data)\\n my_dataloader = torch.utils.data.DataLoader(data, shuffle=shuffle, batch_size=batch_size)\\n return my_dataloader\",\n \"def fetch_dataloader(types, data_dir, hyper_params, train_idx=None, val_idx=None):\\n dataloaders = {}\\n \\n # TODO: write this to hyper_params, make hyper_params an out variable? then save? yes, AND: when ONLY test is requested, load from hyperparams!\\n # TODO: also, add 3rd variation of types: for testing, only read it from hyper_params (DO I NEED TO READ HYPER_PARAMS FOR JUST TESTING?)\\n if train_idx is not None:\\n mean, std = mean_std_calc(DataLoader(Subset(Heart2DSegmentationDataset(str(Path(data_dir) / \\\"train_heart_scans\\\"), hyper_params.endo_or_epi), train_idx)))\\n hyper_params.mean = mean.item()\\n hyper_params.std = std.item()\\n else:\\n if 'train' in types:\\n mean, std = mean_std_calc(DataLoader(Heart2DSegmentationDataset(str(Path(data_dir) / \\\"train_heart_scans\\\"), hyper_params.endo_or_epi)))\\n hyper_params.mean = mean.item()\\n hyper_params.std = std.item()\\n else:\\n mean, std = torch.tensor(hyper_params.mean), torch.tensor(hyper_params.std)\\n \\n print(\\\"Mean: {}, Std: {}\\\".format(mean.item(), std.item()))\\n # borrowed from http://pytorch.org/tutorials/advanced/neural_style_tutorial.html\\n # and http://pytorch.org/tutorials/beginner/data_loading_tutorial.html\\n train_transformer = transforms.Compose([\\n transforms.Normalize(mean=[mean.item()], std=[std.item()])\\n ])\\n \\n eval_transformer = transforms.Compose([\\n transforms.Normalize(mean=[mean.item()], std=[std.item()])\\n ])\\n\\n for split in ['train', 'val', 'test']:\\n if split in types:\\n path = str(Path(data_dir) / \\\"{}_heart_scans\\\".format(split if split != 'val' else 'train'))\\n\\n if split == 'train':\\n if train_idx is not None:\\n dl = DataLoader(Subset(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, train_transformer), train_idx), \\n batch_size=hyper_params.batch_size, \\n shuffle=True,\\n num_workers=hyper_params.num_workers,\\n pin_memory=hyper_params.cuda)\\n else:\\n dl = DataLoader(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, train_transformer), \\n batch_size=hyper_params.batch_size, \\n shuffle=True,\\n num_workers=hyper_params.num_workers,\\n pin_memory=hyper_params.cuda)\\n else:\\n if (split == 'val') and (val_idx is not None): \\n dl = DataLoader(Subset(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, eval_transformer), val_idx), \\n batch_size=hyper_params.batch_size, \\n shuffle=False,\\n num_workers=hyper_params.num_workers,\\n pin_memory=hyper_params.cuda) \\n else:\\n dl = DataLoader(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, eval_transformer), \\n batch_size=hyper_params.batch_size, \\n shuffle=False,\\n num_workers=hyper_params.num_workers,\\n pin_memory=hyper_params.cuda)\\n\\n dataloaders[split] = dl\\n\\n return dataloaders\",\n \"def get_dataloader(\\n path='data/interim/data.json',\\n train_test_split=0.8,\\n batch_size_train=5,\\n batch_size_test=5,\\n shuffle_train=True,\\n perm_images=True,\\n transform_train=True,\\n transform_test=False,\\n class_names=None):\\n\\n # use our dataset and defined transformations\\n if class_names is None:\\n dataset = ProdigyDataReader(path, get_transforms(train=transform_train))\\n dataset_test = ProdigyDataReader(path, get_transforms(train=transform_test))\\n else:\\n dataset = ProdigyDataReader(path, get_transforms(train=transform_train),\\n object_categories=class_names)\\n dataset_test = ProdigyDataReader(path, get_transforms(train=transform_test),\\n object_categories=class_names)\\n\\n # split the dataset in train and test set\\n if perm_images:\\n indices = torch.randperm(len(dataset)).tolist()\\n else:\\n indices = list(range(len(dataset)))\\n\\n len_train = int(len(indices) * train_test_split)\\n dataset = torch.utils.data.Subset(dataset, indices[:len_train])\\n dataset_test = torch.utils.data.Subset(dataset_test, indices[len_train:])\\n\\n # define training and validation data loaders\\n data_loader = torch.utils.data.DataLoader(\\n dataset, batch_size=batch_size_train, shuffle=shuffle_train, num_workers=0,\\n collate_fn=collate_fn)\\n\\n data_loader_test = torch.utils.data.DataLoader(\\n dataset_test, batch_size=batch_size_test, shuffle=False, num_workers=0,\\n collate_fn=collate_fn)\\n\\n return [data_loader, data_loader_test]\",\n \"def get_val_dataloader(dataset, datadir, datasize, val_bs):\\n val_dl = None\\n if dataset == 'tinyimagenet':\\n if not os.path.exists('./data/tiny-imagenet-200'):\\n download_and_unzip('http://cs231n.stanford.edu/tiny-imagenet-200.zip','./data/')\\n random_ids = np.random.randint(100000, size=datasize)\\n val_indices = random_ids\\n\\n imagenet_mean = [0.485, 0.456, 0.406]\\n imagenet_std = [0.229, 0.224, 0.225]\\n\\n val_dl = torch.utils.data.DataLoader(\\n torchvision.datasets.ImageFolder(datadir,\\n transform=transforms.Compose([\\n transforms.Resize(32), \\n transforms.ToTensor(),\\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\\n #Phuong 09/26 drop_last=False -> True\\n batch_size=val_bs, drop_last=True, sampler=SubsetRandomSampler(val_indices))\\n \\n elif dataset == 'fmnist':\\n dl_obj = FashionMNIST_truncated\\n transform_val = transforms.Compose([\\n transforms.ToTensor(),])\\n \\n random_ids = np.random.randint(10000, size=datasize)\\n val_indices = random_ids\\n\\n val_ds = dl_obj(datadir, dataidxs=val_indices, train=True, transform=transform_val, download=True)\\n val_dl = torch.utils.data.DataLoader(dataset=val_ds, batch_size=val_bs, shuffle=True, drop_last=False)\\n \\n elif dataset == \\\"cifar10\\\":\\n dl_obj = CIFAR10_truncated\\n transform_val = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Lambda(lambda x: F.pad(\\n Variable(x.unsqueeze(0), requires_grad=False),\\n (4, 4, 4, 4), mode='reflect').data.squeeze()),\\n transforms.ToPILImage(),\\n transforms.RandomCrop(32, padding=4),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\\n transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),\\n # transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\\n\\n ])\\n random_ids = np.random.randint(10000, size=datasize)\\n val_indices = random_ids\\n\\n val_ds = dl_obj(datadir, dataidxs=val_indices, train=True, transform=transform_val, download=True)\\n val_dl = torch.utils.data.DataLoader(dataset=val_ds, batch_size=val_bs, shuffle=True, drop_last=False)\\n\\n\\n return val_dl\",\n \"def _load_data(self):\\n if self._name in BALANCE_DATASET:\\n _loader = dataset_loaders[self._name]\\n xnp, y = _loader()\\n\\n # Train - Test split\\n gen = ShuffleSplit(n_splits=1, random_state=42, test_size=self._test_size).split(xnp)\\n train_idx, test_idx = next(gen)\\n\\n # Train data.\\n self.xnp_tr = xnp[train_idx]\\n self.y_tr = y[train_idx]\\n # Test data.\\n self.xnp_ts = xnp[test_idx]\\n self.y_ts = y[test_idx]\\n\\n else:\\n _loader = dataset_loaders[self._name]\\n xnp, xp, y = _loader()\\n # self.xnp, self.xp, self.y = _loader()\\n\\n # Train - Test split\\n gen = ShuffleSplit(n_splits=1, random_state=42, test_size=self._test_size).split(xnp)\\n train_idx, test_idx = next(gen)\\n\\n # Train data.\\n self.xnp_tr = xnp[train_idx]\\n self.xp_tr = xp[train_idx]\\n self.y_tr = y[train_idx]\\n # Test data.\\n self.xnp_ts = xnp[test_idx]\\n self.xp_ts = xp[test_idx]\\n self.y_ts = y[test_idx]\",\n \"def prepare_demo_dataset(path, reso, batch_size=1):\\r\\n transform = transforms.Compose([\\r\\n transforms.Resize(size=(reso, reso), interpolation=3),\\r\\n transforms.ToTensor()\\r\\n ])\\r\\n\\r\\n img_datasets = DemoDataset(path, transform)\\r\\n dataloader = torch.utils.data.DataLoader(img_datasets, batch_size=batch_size, num_workers=8)\\r\\n\\r\\n return img_datasets, dataloader\",\n \"def training_start(self, dataloader):\\n self.datasize = len(dataloader)\",\n \"def get_test_loader(id_list = './data/sample_submission.csv', root_dir = './data/test/'):\\n data = HumanProteinDataset(id_list, root_dir, transform = transforms.Compose([\\n Rescale((256, 256)), \\n ToTensor()\\n ]))\\n\\n indices = np.arange(len(data))\\n dataloader_test = DataLoader(data, batch_size=10, num_workers=5)\\n\\n return dataloader_test\",\n \"def train(self, data):\\n pass\",\n \"def make_data_loader(examples, batch_size=100, shuffle=True):\\n x, y = zip(*examples) # makes lists of windows and tags\\n x, y = tr.from_numpy(np.array(x)), tr.from_numpy(np.array(y))\\n x, y = x.type(tr.LongTensor), y.type(tr.LongTensor) # convert lists to tensors\\n train = utdata.TensorDataset(x, y)\\n return utdata.DataLoader(train, batch_size, shuffle)\",\n \"def create_trainval_dataloaders(params):\\n # ----------------Create Dataset objects and Dataloaders----------------\\n mr_dataset_train, tokenizer = get_dataset(params, run_mode=\\\"train\\\")\\n params.vocab_size = tokenizer.get_vocab_size()\\n print(\\\"SystemLog: Vocab size used for training is %d\\\" % (params.vocab_size))\\n print(\\\"SystemLog: Number of items in the train dataset=%d\\\" % len(mr_dataset_train))\\n sys.stdout.flush()\\n # Collate Function pads the sequences to have a uniform length for the entire batch\\n mr_dataloader_train = DataLoader(mr_dataset_train, batch_size=params.batch_size,\\n shuffle=True, num_workers=params.num_workers, collate_fn=CollateMRSequence(params.architecture))\\n\\n mr_dataset_valid, _ = get_dataset(params, run_mode=\\\"valid\\\")\\n print(\\\"SystemLog: Number of items in the valid dataset=%d\\\" % len(mr_dataset_valid))\\n mr_dataloader_valid = DataLoader(mr_dataset_valid, batch_size=params.batch_size_validation,\\n shuffle=False, num_workers=0, collate_fn=CollateMRSequence(params.architecture))\\n\\n return mr_dataset_train, mr_dataloader_train, mr_dataset_valid, mr_dataloader_valid\",\n \"def build_dataloader(cfg, augmentor=None, mode='train', dataset=None, rank=None,\\n dataset_class=VolumeDataset, dataset_options={}, cf=collate_fn_train):\\n assert mode in ['train', 'val', 'test']\\n print('Mode: ', mode)\\n\\n if mode == 'train':\\n batch_size = cfg.SOLVER.SAMPLES_PER_BATCH\\n elif mode == 'val':\\n batch_size = cfg.SOLVER.SAMPLES_PER_BATCH * 4\\n else:\\n cf = collate_fn_test # update the collate function\\n batch_size = cfg.INFERENCE.SAMPLES_PER_BATCH * cfg.SYSTEM.NUM_GPUS\\n\\n if dataset is None: # no pre-defined dataset instance\\n if cfg.MODEL.TARGET_OPT_MULTISEG_SPLIT is not None:\\n dataset_class = VolumeDatasetMultiSeg\\n dataset = get_dataset(cfg, augmentor, mode, rank, dataset_class, dataset_options)\\n\\n sampler = None\\n num_workers = cfg.SYSTEM.NUM_CPUS\\n if cfg.SYSTEM.DISTRIBUTED:\\n num_workers = cfg.SYSTEM.NUM_CPUS // cfg.SYSTEM.NUM_GPUS\\n if cfg.DATASET.DISTRIBUTED == False:\\n sampler = torch.utils.data.distributed.DistributedSampler(dataset)\\n\\n # In PyTorch, each worker will create a copy of the Dataset, so if the data\\n # is preload the data, the memory usage should increase a lot.\\n # https://discuss.pytorch.org/t/define-iterator-on-dataloader-is-very-slow/52238/2\\n img_loader = torch.utils.data.DataLoader(\\n dataset, batch_size=batch_size, shuffle=False, collate_fn=cf,\\n sampler=sampler, num_workers=num_workers, pin_memory=True)\\n\\n return img_loader\",\n \"def dataio_prepare(hparams):\\n data_folder = hparams[\\\"data_folder\\\"]\\n\\n train_data = dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"train_data\\\"],\\n replacements={\\\"data_root\\\": data_folder}, )\\n\\n if hparams[\\\"sorting\\\"] == \\\"ascending\\\":\\n # we sort training data to speed up training and get better results.\\n train_data = train_data.filtered_sorted(sort_key=\\\"duration\\\")\\n # when sorting do not shuffle in dataloader ! otherwise is pointless\\n hparams[\\\"train_dataloader_opts\\\"][\\\"shuffle\\\"] = False\\n\\n elif hparams[\\\"sorting\\\"] == \\\"descending\\\":\\n train_data = train_data.filtered_sorted(\\n sort_key=\\\"duration\\\", reverse=True)\\n # when sorting do not shuffle in dataloader ! otherwise is pointless\\n hparams[\\\"train_dataloader_opts\\\"][\\\"shuffle\\\"] = False\\n\\n elif hparams[\\\"sorting\\\"] == \\\"random\\\":\\n pass\\n\\n else:\\n raise NotImplementedError(\\n \\\"sorting must be random, ascending or descending\\\")\\n\\n valid_data = dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"valid_data\\\"],\\n replacements={\\\"data_root\\\": data_folder}, )\\n valid_data = valid_data.filtered_sorted(sort_key=\\\"duration\\\")\\n\\n test_data = dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"test_data\\\"],\\n replacements={\\\"data_root\\\": data_folder}, )\\n test_data = test_data.filtered_sorted(sort_key=\\\"duration\\\")\\n\\n datasets = [train_data, valid_data, test_data]\\n\\n # Defining tokenizer and loading it\\n tokenizer = transformers.BertTokenizer.from_pretrained('bert-base-chinese')\\n\\n # 2. Define audio pipeline:\\n @data_pipeline.takes(\\\"wav\\\")\\n @data_pipeline.provides(\\\"sig\\\")\\n def audio_pipeline(wav):\\n sig = dataio.read_audio(wav)\\n return sig\\n\\n dataset.add_dynamic_item(datasets, audio_pipeline)\\n\\n # 3. Define text pipeline:\\n @data_pipeline.takes(\\\"transcript\\\")\\n @data_pipeline.provides(\\\"wrd\\\", \\\"tokens_list\\\", \\\"tokens\\\")\\n def text_pipeline(wrd):\\n wrd = \\\"\\\".join(wrd.split(\\\" \\\"))\\n yield wrd\\n tokens_list = tokenizer(wrd)[\\\"input_ids\\\"]\\n yield tokens_list\\n tokens = numpy.array(tokens_list, dtype=\\\"int64\\\")\\n yield tokens\\n\\n dataset.add_dynamic_item(datasets, text_pipeline)\\n\\n # 4. Set output:\\n dataset.set_output_keys(\\n datasets,\\n [\\\"id\\\", \\\"sig\\\", \\\"wrd\\\", \\\"tokens\\\"], )\\n\\n # 5. If Dynamic Batching is used, we instantiate the needed samplers.\\n train_batch_sampler = None\\n valid_batch_sampler = None\\n if hparams[\\\"dynamic_batching\\\"]:\\n from sampler import DynamicBatchSampler # noqa\\n\\n dynamic_hparams = hparams[\\\"dynamic_batch_sampler\\\"]\\n num_buckets = dynamic_hparams[\\\"num_buckets\\\"]\\n\\n train_batch_sampler = DynamicBatchSampler(\\n train_data,\\n dynamic_hparams[\\\"max_batch_len\\\"],\\n num_buckets=num_buckets,\\n length_func=lambda x: x[\\\"duration\\\"],\\n shuffle=dynamic_hparams[\\\"shuffle_ex\\\"],\\n batch_ordering=dynamic_hparams[\\\"batch_ordering\\\"], )\\n\\n valid_batch_sampler = DynamicBatchSampler(\\n valid_data,\\n dynamic_hparams[\\\"max_batch_len\\\"],\\n num_buckets=num_buckets,\\n length_func=lambda x: x[\\\"duration\\\"],\\n shuffle=dynamic_hparams[\\\"shuffle_ex\\\"],\\n batch_ordering=dynamic_hparams[\\\"batch_ordering\\\"], )\\n\\n return (train_data, valid_data, test_data, tokenizer, train_batch_sampler,\\n valid_batch_sampler, )\",\n \"def prepare_data(self,d):\\n train_loaders, train_iters = {}, {}\\n unlabeled_loaders, unlabeled_iters = {}, {}\\n for domain in opt.domains:\\n #CONVERT TO FLOAT32\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\\n train = data_utils.TensorDataset(features,target)\\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\\n train_iters[domain] = iter(train_loaders[domain])\\n for domain in opt.unlabeled_domains:\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\\n uset = data_utils.TensorDataset(features,target)\\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\\n \\n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters\",\n \"def test_dataloader(self, batch_size: Optional[int] = None) -> DataLoader:\\n if self.test is not None:\\n dataset = TabularDataset(\\n task=self.config.task,\\n data=self.test,\\n categorical_cols=self.config.categorical_cols,\\n continuous_cols=self.config.continuous_cols,\\n embed_categorical=(not self.do_leave_one_out_encoder()),\\n target=self.target,\\n )\\n return DataLoader(\\n dataset,\\n batch_size if batch_size is not None else self.batch_size,\\n shuffle=False,\\n num_workers=self.config.num_workers,\\n pin_memory=self.config.pin_memory,\\n )\",\n \"def get_each_loader(data_path, batch_size, trn_negnum, shuffle=True, num_workers=0):\\n \\n dataset = ML_Dataset(data_path, trn_negnum)\\n \\n if data_path.endswith('trn') == True:\\n collate = dataset.train_collate\\n else:\\n collate = test_collate\\n\\n data_loader = data.DataLoader(dataset=dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n num_workers=num_workers,\\n collate_fn=collate)\\n\\n return data_loader\",\n \"def __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\\n \\n self._results_ = None\",\n \"def train(self, train_loader):\\n pass\",\n \"def load_data(self,split='train'):\\n raise NotImplementedError\",\n \"def get_dataloader(hp: HParams) \\\\\\n -> Tuple[torch.utils.data.DataLoader, torch.utils.data.DataLoader, int]:\\n if hp.data.dataset == \\\"podcast\\\":\\n dataset = podcast.PODCAST(root=hp.data.path,\\n audio_folder=hp.data.audio_folder,\\n text_file=hp.data.text_file)\\n length = len(dataset)\\n train_length = int(0.9 * length)\\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\\n length - train_length])\\n\\n # https://towardsdatascience.com/7-tips-for-squeezing-maximum-performance-from-pytorch-ca4a40951259\\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n return train_dataloader, test_dataloader, int(0.9 * length)\\n\\n elif hp.data.dataset == \\\"librispeech\\\":\\n Path(hp.data.path).mkdir(parents=True, exist_ok=True)\\n dataset = librispeech.download_data(root=hp.data.path, url=hp.data.url)\\n length = len(dataset)\\n train_length = int(0.9 * length)\\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\\n length - train_length])\\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n return train_dataloader, test_dataloader, int(0.9 * length)\\n\\n elif hp.data.dataset == \\\"ljspeech\\\":\\n Path(hp.data.path).mkdir(parents=True, exist_ok=True)\\n dataset = ljspeech.download_data(root=hp.data.path)\\n length = len(dataset)\\n train_length = int(0.9 * length)\\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\\n length - train_length])\\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n\\n return train_dataloader, test_dataloader, int(0.9 * length)\\n\\n else:\\n raise Exception(f\\\"Dataset {hp.data.dataset} does not exist\\\")\",\n \"def get_dataloader(params, format_name='hdf5', **kwargs):\\n \\n Provider = get_proper_provider(format_name)(params.modality)\\n \\n return DataLoader(Provider(params.dataset_path,\\n seq_length=params.seq_length),\\n batch_size=params.batch_size,\\n shuffle=params.is_training,\\n num_workers=params.num_workers,\\n pin_memory=params.cuda,\\n collate_fn=pad_collate)\",\n \"def load_data(self,split='train'):\\n return load_arrow_data(self.config,split)\",\n \"def data_loader(edges,features,y):\\n\\n\\n edge_index = torch.tensor(edges, dtype=torch.long)\\n edge_index = edge_index.t().contiguous()\\n x = torch.tensor(features.todense(), dtype=torch.float)\\n\\n y = torch.tensor(y)\\n\\n data = Data(x=x, edge_index=edge_index, y = y)\\n\\n return data\",\n \"def load_data(data_feeder):\\n return data_feeder(BATCH_SIZE,\\n SEQ_LEN,\\n OVERLAP,\\n Q_LEVELS,\\n Q_ZERO,\\n Q_TYPE)\",\n \"def load(self, config, dataset_type, *args, **kwargs):\\n base_dataset_name = config.get(\\\"base_dataset_name\\\", \\\"vqa2\\\")\\n base_dataset_config = config.get(\\\"base_dataset\\\", config)\\n # instantiate base dataset\\n # instantiate base dataser builder\\n base_dataset_builder_class = registry.get_builder_class(base_dataset_name)\\n base_dataset_builder_instance = base_dataset_builder_class()\\n # build base dataset instance\\n base_dataset_builder_instance.build_dataset(base_dataset_config)\\n base_dataset = base_dataset_builder_instance.load_dataset(\\n base_dataset_config, dataset_type\\n )\\n if hasattr(base_dataset_builder_instance, \\\"update_registry_for_model\\\"):\\n base_dataset_builder_instance.update_registry_for_model(base_dataset_config)\\n\\n # instantiate vinvl dataset\\n vinvl_text_processor = config[\\\"processors\\\"][\\\"text_processor\\\"]\\n with open_dict(base_dataset_config):\\n base_dataset_config[\\\"processors\\\"][\\\"text_processor\\\"] = vinvl_text_processor\\n base_dataset_config[\\\"label_map\\\"] = config[\\\"label_map\\\"]\\n\\n vinvl_dataset = super().load(base_dataset_config, dataset_type, *args, **kwargs)\\n vinvl_dataset.set_base_dataset(base_dataset)\\n return vinvl_dataset\",\n \"def create_dataloader(datafile, dataset_type, batch_size, mechanism, shuffle=False):\\n dataset = MazeDataset(datafile, dataset_type)\\n assert dataset.num_actions == mechanism.num_actions\\n return torch.utils.data.DataLoader(\\n dataset, batch_size=batch_size, shuffle=shuffle, num_workers=0)\",\n \"def __init__(self, dataloader):\\n self._dataloader = dataloader\\n\\n self._iterator = iter(self._dataloader)\",\n \"def test_cached_dataloader(self):\\n\\n v = [\\\"data\\\", \\\"target\\\", \\\"model_out_sqnet\\\"]\\n\\n for data, target in self.train_loader:\\n b, c, h, w = data[v[0]].shape\\n assert data[v[1]].shape == (b, )\\n assert data[v[2]].shape == (b, 100)\\n assert data[v[1]].shape == target.shape\",\n \"def view(\\n self,\\n collate_fn: Union[callable, str] = \\\"batch_of_g_and_y\\\",\\n *args,\\n **kwargs\\n ):\\n # provide default collate function\\n if isinstance(collate_fn, str):\\n collate_fn = getattr(self, collate_fn)\\n\\n return torch.utils.data.DataLoader(\\n dataset=self,\\n collate_fn=collate_fn,\\n *args,\\n **kwargs,\\n )\",\n \"def get_test_loader(test_dataset,\\n batch_size,\\n num_workers=4,\\n pin_memory=False):\\n data_loader = torchutils.DataLoader(\\n test_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=pin_memory)\\n return data_loader\",\n \"def get_loader(file_path, src_word2id, trg_word2id, intent_type=None, intent2index=None, batch_size=1):\\n dials = json.load(open(file_path))\\n dataset_list = []\\n for name in dials.keys():\\n val_file = dials[name]\\n # build a custom dataset\\n dataset = MultiwozSingleDataset(val_file, name, src_word2id, trg_word2id, intent_type, intent2index)\\n dataset_list.append(dataset)\\n datasets = ConcatDataset(dataset_list)\\n # data loader for custome dataset\\n data_loader = DataLoader(dataset=datasets,\\n batch_size=batch_size,\\n shuffle=True,\\n num_workers=0,\\n collate_fn=collate_fn)\\n return data_loader\",\n \"def get_dataloader(self, cid, batch_size=None, type=\\\"train\\\"):\\n dataset = self.get_dataset(cid, type)\\n batch_size = len(dataset) if batch_size is None else batch_size\\n data_loader = DataLoader(dataset, batch_size=batch_size)\\n return data_loader\",\n \"def dataloader_vatexEnglish_test(args, tokenizer, subset=\\\"test\\\"):\\n\\n vatexEnglish_dataset = VATEXENGLISH_multi_sentence_dataLoader(\\n subset=subset,\\n data_path=args.data_path,\\n features_path=args.features_path,\\n max_words=args.max_words,\\n feature_framerate=args.feature_framerate,\\n tokenizer=tokenizer,\\n max_frames=args.max_frames,\\n )\\n\\n dataloader = DataLoader(\\n vatexEnglish_dataset,\\n batch_size=args.batch_size_val,\\n num_workers=args.num_thread_reader,\\n shuffle=False,\\n drop_last=False,\\n )\\n return dataloader, len(vatexEnglish_dataset)\",\n \"def load(self, handler, name, size, \\n batch_size=None, shuffle=False, \\n sample_transform=None, batch_transform=None):\\n if sample_transform is None:\\n sample_transform = self.sample_transform\\n if batch_transform is None:\\n batch_transform = self.batch_transform\\n dataset = DatasetIterator(name, size, handler, \\n shuffle=shuffle,\\n transform=sample_transform)\\n if batch_size is None:\\n return dataset\\n batches = BatchIterator(dataset, \\n batch_size=batch_size, \\n transform=batch_transform)\\n return batches\",\n \"def get_dataloader(\\n trainset: VisionDataset,\\n testset: VisionDataset,\\n batch_size: int,\\n n_workers: int,\\n) -> Tuple[data.DataLoader, data.DataLoader]:\\n trainloader = data.DataLoader(\\n trainset,\\n pin_memory=(torch.cuda.is_available()),\\n num_workers=n_workers,\\n shuffle=True,\\n batch_size=batch_size,\\n )\\n testloader = data.DataLoader(\\n testset,\\n pin_memory=(torch.cuda.is_available()),\\n num_workers=n_workers,\\n shuffle=False,\\n batch_size=batch_size,\\n )\\n return trainloader, testloader\",\n \"def build_dataset(input_reader_config,\\n model_config,\\n training,\\n voxel_generator,\\n target_assigner=None):\\n generate_bev = model_config.POST_PROCESSING.use_bev\\n without_reflectivity = model_config.WITHOUT_REFLECTIVITY\\n num_point_features = model_config.NUM_POINT_FEATURES\\n out_size_factor = model_config.BACKBONE.layer_strides[0] //model_config.BACKBONE.upsample_strides[0]\\n cfg = input_reader_config\\n db_sampler_cfg = input_reader_config.DATABASE_SAMPLER\\n db_sampler = None\\n if len(db_sampler_cfg.sample_groups) > 0:\\n db_sampler = build_dbsampler(db_sampler_cfg)\\n try:\\n u_db_sampler_cfg = input_reader_config.UNLABELED_DATABASE_SAMPLER\\n u_db_sampler = None \\n if len(u_db_sampler_cfg.sample_groups) > 0:\\n u_db_sampler = build_dbsampler(u_db_sampler_cfg)\\n except:\\n u_db_sampler = None\\n grid_size = voxel_generator.grid_size #[352,400]\\n feature_map_size = grid_size[:2] // out_size_factor\\n feature_map_size = [*feature_map_size, 1][::-1]\\n\\n prep_func = partial(\\n prep_pointcloud,\\n root_path = cfg.KITTI_ROOT_PATH,\\n class_names = cfg.CLASS_NAMES,\\n voxel_generator=voxel_generator,\\n target_assigner=target_assigner,\\n training=training,\\n max_voxels = cfg.MAX_NUMBER_OF_VOXELS,\\n remove_outside_points = False,\\n create_targets = training,\\n shuffle_points = cfg.SHUFFLE_POINTS,\\n gt_rotation_noise = cfg.GROUNDTRUTH_ROTATION_UNIFORM_NOISE,\\n gt_loc_noise_std = cfg.GROUNDTRUTH_LOCALIZATION_NOISE_STD,\\n global_rotation_noise = cfg.GLOBAL_ROTATION_UNIFORM_NOISE,\\n global_scaling_noise = cfg.GLOBAL_SCALING_UNIFORM_NOISE,\\n global_loc_noise_std = (0.2, 0.2, 0.2),\\n global_random_rot_range = cfg.GLOBAL_RANDOM_ROTATION_RANGE_PER_OBJECT,\\n db_sampler = db_sampler,\\n unlabeled_db_sampler = u_db_sampler,\\n generate_bev = generate_bev,\\n without_reflectivity=without_reflectivity,\\n num_point_features=num_point_features,\\n anchor_area_threshold=cfg.ANCHOR_AREA_THRESHOLD,\\n gt_points_drop=cfg.GROUNDTRUTH_POINTS_DROP_PERCENTAGE,\\n gt_drop_max_keep=cfg.GROUNDTRUTH_DROP_MAX_KEEP_POINTS,\\n remove_points_after_sample=cfg.REMOVE_POINTS_AFTER_SAMPLE,\\n remove_environment=cfg.REMOVE_ENVIRONMENT,\\n use_group_id=False,\\n out_size_factor=out_size_factor)\\n dataset = KittiDataset(\\n info_path = cfg.KITTI_INFO_PATH,\\n root_path=cfg.KITTI_ROOT_PATH,\\n num_point_features=num_point_features,\\n target_assigner=target_assigner,\\n feature_map_size=feature_map_size,\\n prep_func=prep_func\\n )\\n return dataset\",\n \"def dataset(options):\\n pass\",\n \"def get_loaders(opt):\\n train_samples, val_samples = get_train_val_metadata(opt.dataset_dir,\\n opt.validation_cities,\\n opt.patch_size,\\n opt.stride)\\n print('train samples : ', len(train_samples))\\n print('val samples : ', len(val_samples))\\n\\n logging.info('STARTING Dataset Creation')\\n\\n full_load = full_onera_loader(opt.dataset_dir, opt)\\n\\n train_dataset = OneraPreloader(opt.dataset_dir,\\n train_samples,\\n full_load,\\n opt.patch_size,\\n opt.augmentation)\\n val_dataset = OneraPreloader(opt.dataset_dir,\\n val_samples,\\n full_load,\\n opt.patch_size,\\n False)\\n\\n logging.info('STARTING Dataloading')\\n\\n train_loader = torch.utils.data.DataLoader(train_dataset,\\n batch_size=opt.batch_size,\\n shuffle=True,\\n num_workers=opt.num_workers)\\n val_loader = torch.utils.data.DataLoader(val_dataset,\\n batch_size=opt.batch_size,\\n shuffle=False,\\n num_workers=opt.num_workers)\\n return train_loader, val_loader\",\n \"def val_dataloader(self) -> DataLoader:\\n loader_val = DataLoader(\\n self.dataset_valid, \\n batch_size=int(1.5 * self.args.batch_size),\\n num_workers=self.args.num_workers,\\n pin_memory=self.args.pin_mem,\\n drop_last=False\\n )\\n return loader_val\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7731121","0.7497621","0.72368264","0.71800596","0.7143441","0.7102657","0.7093028","0.7014497","0.6950995","0.6860976","0.6830999","0.67986304","0.6784964","0.6782085","0.67802626","0.6743672","0.6729586","0.6659931","0.66424596","0.6627726","0.6623991","0.6619608","0.6609511","0.6607341","0.6604726","0.657813","0.6576271","0.65512574","0.6545428","0.6526977","0.65076834","0.6502126","0.64992815","0.6496821","0.6457729","0.6421005","0.6420917","0.6414877","0.64116997","0.6411119","0.6398087","0.638023","0.63724226","0.6312742","0.6309674","0.629974","0.6297318","0.6295838","0.6291873","0.62912697","0.6276868","0.6268379","0.6264112","0.6262327","0.62587154","0.6255372","0.6253363","0.6244811","0.62433755","0.6239795","0.62219775","0.62109774","0.62102616","0.62050986","0.62050307","0.62046003","0.61895186","0.61859834","0.61853355","0.61751187","0.61688215","0.61593294","0.61507237","0.6146844","0.61444676","0.6138137","0.61034745","0.6088552","0.60823107","0.6081238","0.6079754","0.6076254","0.6068267","0.6066863","0.60566676","0.60515976","0.60493773","0.6049095","0.604589","0.60440785","0.6043266","0.6040748","0.60291326","0.6021906","0.6019508","0.60100526","0.59987366","0.5991421","0.59879994","0.59800124","0.5977117"],"string":"[\n \"0.7731121\",\n \"0.7497621\",\n \"0.72368264\",\n \"0.71800596\",\n \"0.7143441\",\n \"0.7102657\",\n \"0.7093028\",\n \"0.7014497\",\n \"0.6950995\",\n \"0.6860976\",\n \"0.6830999\",\n \"0.67986304\",\n \"0.6784964\",\n \"0.6782085\",\n \"0.67802626\",\n \"0.6743672\",\n \"0.6729586\",\n \"0.6659931\",\n \"0.66424596\",\n \"0.6627726\",\n \"0.6623991\",\n \"0.6619608\",\n \"0.6609511\",\n \"0.6607341\",\n \"0.6604726\",\n \"0.657813\",\n \"0.6576271\",\n \"0.65512574\",\n \"0.6545428\",\n \"0.6526977\",\n \"0.65076834\",\n \"0.6502126\",\n \"0.64992815\",\n \"0.6496821\",\n \"0.6457729\",\n \"0.6421005\",\n \"0.6420917\",\n \"0.6414877\",\n \"0.64116997\",\n \"0.6411119\",\n \"0.6398087\",\n \"0.638023\",\n \"0.63724226\",\n \"0.6312742\",\n \"0.6309674\",\n \"0.629974\",\n \"0.6297318\",\n \"0.6295838\",\n \"0.6291873\",\n \"0.62912697\",\n \"0.6276868\",\n \"0.6268379\",\n \"0.6264112\",\n \"0.6262327\",\n \"0.62587154\",\n \"0.6255372\",\n \"0.6253363\",\n \"0.6244811\",\n \"0.62433755\",\n \"0.6239795\",\n \"0.62219775\",\n \"0.62109774\",\n \"0.62102616\",\n \"0.62050986\",\n \"0.62050307\",\n \"0.62046003\",\n \"0.61895186\",\n \"0.61859834\",\n \"0.61853355\",\n \"0.61751187\",\n \"0.61688215\",\n \"0.61593294\",\n \"0.61507237\",\n \"0.6146844\",\n \"0.61444676\",\n \"0.6138137\",\n \"0.61034745\",\n \"0.6088552\",\n \"0.60823107\",\n \"0.6081238\",\n \"0.6079754\",\n \"0.6076254\",\n \"0.6068267\",\n \"0.6066863\",\n \"0.60566676\",\n \"0.60515976\",\n \"0.60493773\",\n \"0.6049095\",\n \"0.604589\",\n \"0.60440785\",\n \"0.6043266\",\n \"0.6040748\",\n \"0.60291326\",\n \"0.6021906\",\n \"0.6019508\",\n \"0.60100526\",\n \"0.59987366\",\n \"0.5991421\",\n \"0.59879994\",\n \"0.59800124\",\n \"0.5977117\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7398,"cells":{"query":{"kind":"string","value":"Computes the precision for the specified values of k"},"document":{"kind":"string","value":"def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res"},"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 precision(gt, pred, k):\n k = min(len(pred), k)\n den = min(len(gt), k)\n return sum([int(pred[i] in gt) for i in range(k)]) / den","def precision_at_k(r, k):\n assert k >= 1\n r = np.asarray(r)[:k] != 0\n if r.size != k:\n raise ValueError('Relevance score length < k')\n return np.mean(r)","def precision_at_k(r, k):\n assert k >= 1\n r = np.asarray(r)[:k] != 0\n if r.size != k:\n raise ValueError('Relevance score length < k')\n return np.mean(r)","def get_precision(self, k=None):\n k = 1 if k is None else k\n precisions = []\n \n for query, answer in tqdm(zip(self.test_queries, self.results)):\n correct_set = self.correct_answers[query]\n n_relevant = 0\n for candidate in answer[:k]:\n if candidate in correct_set:\n n_relevant += 1\n precisions.append(n_relevant / k)\n \n return np.mean(precisions)","def metric_precision_at_k(pred: list, echt: list, k: int):\n echt_keys = [key for key, _ in echt[:k]]\n return sum([1.0 for key, _ in pred[:k] if key in echt_keys]) / float(k)","def precision_at_k(model, ratings, k, relevance_func):\n predictions = model.predict_all()\n np.place(predictions, ratings == 0, -np.Inf)\n recommended = predictions.argsort(1)[::, :-k-1:-1]\n \n relevance_per_user = np.take_along_axis(ratings, recommended, 1)\n max_relevance_per_user = (relevance_per_user > 0).sum(1)\n relevance_per_user = relevance_func(relevance_per_user).sum(1)\n\n precision = np.divide(relevance_per_user, max_relevance_per_user)\n \n return np.nanmean(precision)","def precision_recall_at_k(predictions, k=10, threshold=3.5):\r\n\r\n # First map the predictions to each user.\r\n user_est_true = defaultdict(list)\r\n for uid, _, true_r, est, _ in predictions:\r\n user_est_true[uid].append((est, true_r))\r\n\r\n precisions = dict()\r\n recalls = dict()\r\n for uid, user_ratings in user_est_true.items():\r\n\r\n # Sort user ratings by estimated value\r\n user_ratings.sort(key=lambda x: x[0], reverse=True)\r\n\r\n # Number of relevant items\r\n n_rel = sum((true_r >= threshold) for (_, true_r) in user_ratings)\r\n\r\n # Number of recommended items in top k\r\n n_rec_k = sum((est >= threshold) for (est, _) in user_ratings[:k])\r\n\r\n # Number of relevant and recommended items in top k\r\n n_rel_and_rec_k = sum(((true_r >= threshold) and (est >= threshold))\r\n for (est, true_r) in user_ratings[:k])\r\n\r\n # Precision@K: Proportion of recommended items that are relevant\r\n # When n_rec_k is 0, Precision is undefined. We here set it to 0.\r\n\r\n precisions[uid] = n_rel_and_rec_k / n_rec_k if n_rec_k != 0 else 0\r\n\r\n # Recall@K: Proportion of relevant items that are recommended\r\n # When n_rel is 0, Recall is undefined. We here set it to 0.\r\n\r\n recalls[uid] = n_rel_and_rec_k / n_rel if n_rel != 0 else 0\r\n\r\n return precisions, recalls","def precision_at(\n ks: torch.Tensor, scores: torch.Tensor, labels: torch.Tensor\n) -> torch.Tensor:\n\n ks, scores, labels = _check_inputs(ks, scores, labels)\n _, _, topk_labels = _extract_topk(ks, scores, labels)\n precisions = _create_output_placeholder(scores, ks)\n\n for index, k in enumerate(ks):\n precisions[:, index] = torch.sum(topk_labels[:, : int(k)], dim=1) / float(k)\n\n return precisions","def precision_at_k(r, k = None):\n assert k is None or k >= 1\n r = np.asarray(r)[:k] != 0\n if r.size != k and k is not None:\n raise ValueError('Relevance score length < k')\n return np.mean(r)","def precision_recall_at_k(predictions, k, threshold):\n # First map the predictions to each user.\n user_est_true = defaultdict(list)\n for uid, _, true_r, est, _ in predictions:\n user_est_true[uid].append((est, true_r))\n\n precisions = dict()\n recalls = dict()\n for uid, user_ratings in user_est_true.items():\n\n # Sort user ratings by estimated value\n user_ratings.sort(key=lambda x: x[0], reverse=True)\n\n # Number of relevant items\n n_rel = sum((true_r >= threshold) for (_, true_r) in user_ratings)\n\n # Number of recommended items in top k\n n_rec_k = sum((est >= threshold) for (est, _) in user_ratings[:k])\n\n # Number of relevant and recommended items in top k\n n_rel_and_rec_k = sum(((true_r >= threshold) and (est >= threshold))\n for (est, true_r) in user_ratings[:k])\n\n # Precision@K: Proportion of recommended items that are relevant\n precisions[uid] = n_rel_and_rec_k / n_rec_k if n_rec_k != 0 else 1\n\n # Recall@K: Proportion of relevant items that are recommended\n recalls[uid] = n_rel_and_rec_k / n_rel if n_rel != 0 else 1\n\n # Precision and recall can then be averaged over all users\n overall_precisions = sum(\n prec for prec in precisions.values()) / len(precisions)\n overall_recalls = sum(rec for rec in recalls.values()) / len(recalls)\n\n return overall_precisions, overall_recalls","def test2_precision_1d(self):\n arr1 = np.array([0, 1, 1])\n scores1 = np.array([0.2, 0.3, 0.5])\n scores1_not_sum_1 = np.array([x * 1542 for x in scores1])\n\n k = 1\n expected_normalized_precision_at_k = 1.0\n expected_precision_at_k = 1.0\n\n actual_normalized = ranking.precision_at_k(y_true=arr1, y_score=scores1, k=k, normalize=True)\n actual_normalized_not_sum_1 = ranking.precision_at_k(y_true=arr1, y_score=scores1_not_sum_1, k=k,\n normalize=True)\n actual = ranking.precision_at_k(y_true=arr1, y_score=scores1, k=k, normalize=False)\n actual_not_sum_1 = ranking.precision_at_k(y_true=arr1, y_score=scores1_not_sum_1, k=k, normalize=False)\n\n self.assertEqual(expected_normalized_precision_at_k, actual_normalized)\n self.assertEqual(expected_normalized_precision_at_k, actual_normalized_not_sum_1)\n self.assertEqual(expected_precision_at_k, actual)\n self.assertEqual(expected_precision_at_k, actual_not_sum_1)\n\n k = 2\n expected_normalized_precision_at_k = 1.0\n expected_precision_at_k = 1.0\n\n actual_normalized = ranking.precision_at_k(y_true=arr1, y_score=scores1, k=k, normalize=True)\n actual_normalized_not_sum_1 = ranking.precision_at_k(y_true=arr1, y_score=scores1_not_sum_1, k=k,\n normalize=True)\n actual = ranking.precision_at_k(y_true=arr1, y_score=scores1, k=k, normalize=False)\n actual_not_sum_1 = ranking.precision_at_k(y_true=arr1, y_score=scores1_not_sum_1, k=k, normalize=False)\n\n self.assertEqual(expected_normalized_precision_at_k, actual_normalized)\n self.assertEqual(expected_normalized_precision_at_k, actual_normalized_not_sum_1)\n self.assertEqual(expected_precision_at_k, actual)\n self.assertEqual(expected_precision_at_k, actual_not_sum_1)","def pr_at_k(rels, expected_count, k):\n k = min(k, len(rels))\n TP = sum(rels[:k])\n FP = k - TP\n FN = expected_count - TP\n TN = len(rels[k:]) - sum(rels[k:])\n assert TN >= 0.0\n return TP / (TP + FP), TP / (TP + FN), TP / (TP + TN) if TP + TN > 0 else 0","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\r\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\r\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\r\n precision = true_positives / (predicted_positives + K.epsilon())\r\n return precision","def precision(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def precision(y_true, y_pred):\r\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\r\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\r\n precision = true_positives / (predicted_positives + K.epsilon())\r\n return precision","def precision(y_true, y_pred):\r\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\r\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\r\n precision = true_positives / (predicted_positives + K.epsilon())\r\n return precision","def precision(y_true, y_pred):\r\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\r\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\r\n precision = true_positives / (predicted_positives + K.epsilon())\r\n return precision","def precision(y_true, y_pred):\r\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\r\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\r\n precision = true_positives / (predicted_positives + K.epsilon())\r\n return precision","def precision(y_true, y_pred):\r\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\r\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\r\n precision = true_positives / (predicted_positives + K.epsilon())\r\n return precision","def precision(y_true, y_pred):\r\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\r\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\r\n precision = true_positives / (predicted_positives + K.epsilon())\r\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def M_Precision(y_true, y_pred):\n\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.constant(K.epsilon()))\n return precision","def retrieval_precision(preds: Tensor, target: Tensor, k: Optional[int]=None, adaptive_k: bool=False) ->Tensor:\n preds, target = _check_retrieval_functional_inputs(preds, target)\n if not isinstance(adaptive_k, bool):\n raise ValueError('`adaptive_k` has to be a boolean')\n if k is None or adaptive_k and k > preds.shape[-1]:\n k = preds.shape[-1]\n if not (isinstance(k, int) and k > 0):\n raise ValueError('`k` has to be a positive integer or None')\n if not target.sum():\n return tensor(0.0, device=preds.device)\n relevant = target[preds.topk(min(k, preds.shape[-1]), dim=-1)[1]].sum().float()\n return relevant / k","def keras_precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def average_precision_at_k(targets, ranked_predictions, k=None):\n if k:\n ranked_predictions = ranked_predictions[:k]\n score = 0.0\n hits = 0.0\n for i, pred in enumerate(ranked_predictions):\n if pred in targets and pred not in ranked_predictions[:i]:\n hits += 1.0\n score += hits / (i + 1.0)\n divisor = min(len(targets), k) if k else len(targets)\n return score / divisor","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def precision(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def cdf(self, k):\n\n if k < 0 or k > self.n:\n return 0\n\n k = int(k)\n ans = 0\n for i in range(0, k + 1):\n ans += self.pmf(i)\n return ans","def getPrecision(y_true, y_pred):\r\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\r\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\r\n precision = true_positives / (predicted_positives + K.epsilon())\r\n return precision","def compute_pr_at_k(k, true_labels, test_statistics=None, pvalues=None):\n if (test_statistics is not None) and (pvalues is not None):\n raise ValueError(\"You cannot supply both `test_statistics` and `pvalues`.\")\n\n if test_statistics is not None:\n res = test_statistics\n reverse_sorting = True\n else:\n res = pvalues\n reverse_sorting = False\n\n label_matrix = np.zeros((len(true_labels), len(true_labels)))\n c1 = (true_labels == 0).sum()\n label_matrix[:c1, :c1] = 1\n\n triu_idx = np.triu_indices_from(res, k=1)\n labels_vec = label_matrix[triu_idx]\n res_vec = res[triu_idx]\n\n idx = np.argsort(res_vec)\n if reverse_sorting:\n idx = idx[::-1]\n sorted_labels = labels_vec[idx]\n\n if isinstance(k, int):\n ks = range(1, k + 1)\n else:\n ks = k\n\n precisions = [sorted_labels[:k].mean() for k in ks]\n recalls = [sorted_labels[:k].sum() / sorted_labels.sum() for k in ks]\n\n return precisions, recalls","def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:\n\n if not nums:\n return 0\n\n if k <= 1:\n return 0\n\n count = 0\n lo = 0\n product = 1\n for hi in range(len(nums)):\n product *= nums[hi]\n while product >= k:\n product /= nums[lo]\n lo += 1\n count += hi - lo + 1\n return count","def prf_cal(y_pred,y_true,k):\r\n GT=np.sum(y_true[y_true==1.])\r\n instance_num=y_true.shape[0]\r\n prediction_num=instance_num*k\r\n\r\n sort_indices = np.argsort(y_pred)\r\n sort_indices=sort_indices[:,::-1]\r\n static_indices = np.indices(sort_indices.shape)\r\n sorted_annotation= y_true[static_indices[0],sort_indices]\r\n top_k_annotation=sorted_annotation[:,0:k]\r\n TP=np.sum(top_k_annotation[top_k_annotation==1.])\r\n recall=TP/GT\r\n precision=TP/prediction_num\r\n f1=2.*recall*precision/(recall+precision)\r\n return precision, recall, f1","def apk(y_true, y_pred, k):\n \n # initialize p@k list of values\n pk_values = []\n \n # loop over all k. from 1 to k+1\n for i in range(1, k + 1):\n # calculate p@i and append to list\n pk_values.append(pk(y_true, y_pred, i))\n \n # if we have no values in the list, return 0\n if len(pk_values) == 0:\n return 0\n # else, we return the sum of list over length of list\n return sum(pk_values) / len(pk_values)","def mapk(actual, predicted, k):\n return round(np.mean([apk(a,p,k) for a,p in zip(actual, predicted)]), 4) * 100","def __init__(self, k=10, cutoff=0.5):\n if k < 0:\n raise ValueError('k must be positive')\n super(Precision, self).__init__()\n self.k = k\n self.cutoff = cutoff","def _K(s):\n p = 0\n for k in range(-10, 10, 1):\n p += (-1)**k * np.exp(-2 * k**2 * s**2)\n return p","def ensure_positive_precision(K):\n K_diag = np.diag(np.diag(K))\n K = np.where(np.any(np.diag(K) < 0), np.where(K_diag < 0, 1e-2, K_diag), K)\n return K","def _compute_parameters(self, p, k):\n for i in range(self._.d + 1):\n p[0, i, i] = k[i]\n p[i, 0, i] = Integer(1)\n p[i, i, 0] = Integer(1)\n for i in range(self._.d):\n p[i+1, 1, i+1] = self._.a[i+1]\n p[i, 1, i+1] = self._.b[i]\n p[i+1, 1, i] = self._.c[i+1]\n for i in range(2, self._.d + 1):\n for j in range(1, self._.d + 1):\n for h in range(1, self._.d):\n p[h, i, j] = self._check_parameter(\n h, i, j,\n _simplify(_expand((\n self._.c[h] * p[h-1, i-1, j]\n + self._.b[h] * p[h+1, i-1, j]\n - self._.b[i-2] * p[h, i-2, j]\n + (self._.a[h] - self._.a[i-1]) * p[h, i-1, j]\n ) / self._.c[i])))\n p[self._.d, i, j] = self._check_parameter(\n self._.d, i, j,\n _simplify(_expand((\n self._.c[self._.d] * p[self._.d-1, i-1, j]\n - self._.b[i-2] * p[self._.d, i-2, j]\n + (self._.a[self._.d] - self._.a[i-1])\n * p[self._.d, i-1, j]\n ) / self._.c[i])))","def _calculate_probability(self,k):\n\t\tif abs(k * self.delta_x) > (3 * np.sqrt(self.variance)):\n\t\t\treturn 0.0\n\t\tbinom_coeff = special.binom(self.n,(self.n + k)/2)\n\t\tb_value = binom_coeff * ((self.p) ** ((self.n + k)/2)) * ((1-self.p) ** ((self.n - k)/2))\n\t\treturn b_value","def kx(self, k: int) -> float:\n result = self._read_inline(f\"kx({k})\")\n return result","def pmf(self, k):\n\n if k < 0 or k > self.n:\n return 0\n\n k = int(k)\n\n c = (Binomial.factorial(self.n)) / \\\n (Binomial.factorial(k) * self.factorial((self.n - k)))\n\n return c * pow(self.p, k) * pow((1 - self.p), (self.n - k))","def probability(n, k, p):\n prob = 0\n power = expotentation_by_squaring((1-p), n)\n count_mult = math.log(n, 2)\n p_fraction = p/(1-p)\n count_mult += 1\n for i in range(0, k+1):\n element = newton(n, i)*power\n prob += element\n power *= p_fraction\n count_mult += 2\n return prob, count_mult","def precision(y_true, y_pred):\n true_positives = bk.sum(bk.round(bk.clip(y_true * y_pred, 0, 1)))\n predicted_positives = bk.sum(bk.round(bk.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + bk.epsilon())\n return precision","def recall_at_k(self, positions, k, num_samples):\n return 1.0 * sum(i <= k for i in positions) / num_samples","def params_to_precision(kernel):\n\n return kernel.precision()","def pkscore(labels, preds, k=10):\n # Remove padding from labels and preds\n mask = np.where(labels<=1, True, False)\n labels = labels[mask]\n preds = preds[mask]\n\n num_windows = len(labels) - k + 1\n assert num_windows>0, 'Choose a smaller k value'\n\n correct = 0\n for i in range(num_windows):\n # calculate index of window close\n j = i + k\n\n # Get number of segment splits in labels and preds\n label_diff = sum(labels[i:j])\n pred_diff = sum(preds[i:j])\n\n # Check for agreement between labels and preds\n if (label_diff and pred_diff) or (not label_diff and not pred_diff):\n correct += 1\n return 1-(correct/(num_windows))","def queryPrecision(self, query_doc_IDs_ordered, query_id, true_doc_IDs, k):\n\n\t\tprecision = -1\n\n\t\t#Fill in code here\n\t\trel_ret = 0 # no. of relevant docs retrieved\n\n\t\tfor docID in query_doc_IDs_ordered[:k]:\n\t\t\tif docID in true_doc_IDs:\n\t\t\t\trel_ret += 1\n\n\t\tprecision = rel_ret/k\n\n\t\treturn precision","def expected_jk_variance(K):\r\n\r\n kf = float(K)\r\n return ((1 / kf) * (kf - 1) / (kf - 0.5) *\r\n ((kf - 1) / (kf - 2)) ** 2 * (kf - 3) / (kf - 2))","def test_approximate_gamma(self, k):\n mean_column = prior.PriorParams.field_index(\"mean\")\n var_column = prior.PriorParams.field_index(\"var\")\n x = self.priors[self.n][k][mean_column]\n xvar = self.priors[self.n][k][var_column]\n # match mean/variance\n alpha_0, beta_0 = approximate_gamma_mom(x, xvar)\n ck_x = alpha_0 / beta_0\n ck_xvar = alpha_0 / beta_0**2\n assert np.isclose(x, ck_x)\n assert np.isclose(xvar, ck_xvar)\n # match approximate sufficient statistics\n logx, _, _ = approx.approximate_log_moments(x, xvar)\n alpha_1, beta_1 = approx.approximate_gamma_kl(x, logx)\n ck_x = alpha_1 / beta_1\n ck_logx = hypergeo._digamma(alpha_1) - np.log(beta_1)\n assert np.isclose(x, ck_x)\n assert np.isclose(logx, ck_logx)\n # compare KL divergence between strategies\n kl_0 = kl_divergence(\n lambda x: conditional_coalescent_pdf(x, self.n, k),\n lambda x: scipy.stats.gamma.logpdf(x, alpha_0, scale=1 / beta_0),\n )\n kl_1 = kl_divergence(\n lambda x: conditional_coalescent_pdf(x, self.n, k),\n lambda x: scipy.stats.gamma.logpdf(x, alpha_1, scale=1 / beta_1),\n )\n assert kl_1 < kl_0","def topk_accuracies(preds, labels, ks):\n num_topks_correct = topks_correct(preds, labels, ks)\n return [(x / preds.size(0)) * 100.0 for x in num_topks_correct]","def precision_on_1(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision","def pmf(self, k):\n if k % 1 != 0:\n k = int(k)\n if k < 0 and k <= self.n:\n return 0\n q = 1 - self.p\n co = (self.factorial(self.n) / ((self.factorial(self.n-k)\n * self.factorial(k))))\n q2 = q ** (self.n - k)\n return co * (self.p ** k) * q2","def C(n,k):\n if 0 <= k <= n:\n ntok = 1\n ktok = 1\n for t in xrange(1, min(k, n - k) + 1):\n ntok *= n\n ktok *= t\n n -= 1\n return ntok // ktok\n else:\n return 0","def f1_score_at_k(r, max_rel, k = None):\n p = precision_at_k(r, k)\n r = recall_at_k(r, max_rel, k)\n return 2 * p * r / (p + r)","def calPFP(n, m, k):\n return pow(1-math.exp(-k*(n+0.5)/(m-1)), k)","def kepler(x, k=1.0):\n assert(x.shape[2] == 1)\n\n q,p = extract_q_p(x)\n # The derivative of r wrt q is 1/sqrt(sum(q^2)), which is singular in 0.\n # Cutoff r so that it is > eps.\n eps = 1e-5\n r = tf.sqrt(tf.reduce_sum(tf.square(q), axis=1) + eps)\n return tf.squeeze(0.5 * tf.reduce_sum(tf.square(p), axis=1) + k / r)","def superobl_p(k):\n if k%2==0:\n return 1/2 + 1/(2*(k+1))\n else:\n return 1/2 + 1/(2*k)","def choose(n, k):\r\n if 0 <= k <= n:\r\n ntok = 1\r\n ktok = 1\r\n for t in range(1, min(k, n - k) + 1):\r\n ntok *= n\r\n ktok *= t\r\n n -= 1\r\n return ntok // ktok\r\n else:\r\n return 0","def test_kpa_conversion(self):\n\n result = get_kpa(5.6, 25)\n\n self.assertTrue(result == -34.281679)","def pow_derpy(x, k):\n if k == 1:\n return x\n if k == 0:\n return 1\n\n return x * pow_derpy(x, k - 1)","def k_rank_approximate(doc_matrix, k):\n return []","def n_choose_k(n: int, k: int) -> int:\n # Edge case, no possible way to choose.\n if k > n or k < 0 or n < 0: return 0\n # We choose the min of k or n - k\n # since nCk == nC(n - k).\n k = min(k, n - k)\n # The numerator represents the product\n # n * (n - 1) * (n - 2) * ... * (n - k - 1)\n numerator = reduce(mul, range(n, n - k, -1), 1)\n # The denominator represents the product\n # 1 * 2 * ... * k\n denominator = reduce(mul, range(1, k + 1), 1)\n # return the result as an integer.\n return numerator // denominator","def precisions(self):\n raise NotImplementedError","def get_precision(self):\n ...","def pk(y_true, y_pred, k):\n \n # if k is 0, return 0. we should never have this\n # as k is always >= 1\n if k == 0:\n return 0\n # we are interested only in top-k predictions\n y_pred = y_pred[:k]\n \n # convert predictions to set\n pred_set = set(y_pred)\n \n # convert actual values to set\n true_set = set(y_true)\n \n # find common values\n common_values = pred_set.intersection(true_set)\n \n # return length of common values over k\n return len(common_values) / len(y_pred[:k])","def ranking_precision_score(y_true, y_score, k=10):\n unique_y = np.unique(y_true)\n\n if len(unique_y) > 2:\n raise ValueError(\"Only supported for two relevance levels.\")\n\n n_relevant = 0\n n_pos = 0\n for relevance_score in y_true:\n if relevance_score == 1:\n n_pos += 1\n\n for index in y_score[:k]:\n if y_true[index] == 1:\n n_relevant += 1\n\n # Divide by min(n_pos, k) such that the best achievable score is always 1.0.\n return float(n_relevant) / min(n_pos, k) if min(n_pos, k) > 0 else 0","def kpdf(t,c,tau,k):\n return k*(1-st.gamma.cdf(t,c,loc=0,scale=tau))+(1-k*t)*st.gamma.pdf(t,c,loc=0,scale=tau)","def __init__(self, k=10, cutoff=0.5):\n if k < 0:\n raise ValueError('k must be positive')\n super(PrecisionLower, self).__init__(k, cutoff)","def precision(classifier_output, true_labels):\n\n # TODO: finish this.\n conf_matrix = confusion_matrix(classifier_output, true_labels)\n return conf_matrix[0][0]/(conf_matrix[0][0] + conf_matrix[1][0])","def precision_m(self, y_true, y_pred):\n true_positives = keras.backend.sum(keras.backend.round(keras.backend.clip(y_true * y_pred, 0, 1)))\n predicted_positives = keras.backend.sum(keras.backend.round(keras.backend.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + keras.backend.epsilon())\n return precision","def nCk(n, k):\n return factorial(n)//factorial(k)//factorial(n-k)","def precision(y_true, y_pred):\n true_positives = backend.sum(backend.round(backend.clip(y_true * y_pred, 0, 1)))\n predicted_positives = backend.sum(backend.round(backend.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + backend.epsilon())\n return precision","def calc(k):\n n = factorial(4*k) * (1103.0 + 26390.0*k)\n d = factorial(k)**4 * 396.0**(4.0*k)\n z = n/d\n return z","def __init__(self, k=10, cutoff=0.5):\n if k < 0:\n raise ValueError('k must be positive')\n super(PrecisionUpper, self).__init__(k, cutoff)","def mean_avg_prec_at_k(question_set, candidate_set, k=None):\n # TODO(umaroy): add test for this method on a known set of encodings.\n # Current run_xreqa_eval.sh with X_Y encodings generates mAP of 0.628.\n all_questions = question_set.as_list()\n all_candidates = candidate_set.as_list()\n for embedding_type in ['sentences_and_contexts']:\n candidate_matrix = np.concatenate(\n [np.expand_dims(i.encoding[embedding_type], 0) for i in all_candidates],\n axis=0)\n\n ap_scores = []\n for q in all_questions:\n question_vec = np.expand_dims(q.encoding, 0)\n scores = question_vec.dot(candidate_matrix.T)\n y_true = np.zeros(scores.shape[1])\n all_correct_cands = set(candidate_set.by_xling_id[q.xling_id])\n for ans in all_correct_cands:\n y_true[candidate_set.pos[ans]] = 1\n ap_scores.append(average_precision_at_k(\n np.where(y_true == 1)[0], np.squeeze(scores).argsort()[::-1], k))\n print(embedding_type + \": \" + str(np.mean(ap_scores)))"],"string":"[\n \"def precision(gt, pred, k):\\n k = min(len(pred), k)\\n den = min(len(gt), k)\\n return sum([int(pred[i] in gt) for i in range(k)]) / den\",\n \"def precision_at_k(r, k):\\n assert k >= 1\\n r = np.asarray(r)[:k] != 0\\n if r.size != k:\\n raise ValueError('Relevance score length < k')\\n return np.mean(r)\",\n \"def precision_at_k(r, k):\\n assert k >= 1\\n r = np.asarray(r)[:k] != 0\\n if r.size != k:\\n raise ValueError('Relevance score length < k')\\n return np.mean(r)\",\n \"def get_precision(self, k=None):\\n k = 1 if k is None else k\\n precisions = []\\n \\n for query, answer in tqdm(zip(self.test_queries, self.results)):\\n correct_set = self.correct_answers[query]\\n n_relevant = 0\\n for candidate in answer[:k]:\\n if candidate in correct_set:\\n n_relevant += 1\\n precisions.append(n_relevant / k)\\n \\n return np.mean(precisions)\",\n \"def metric_precision_at_k(pred: list, echt: list, k: int):\\n echt_keys = [key for key, _ in echt[:k]]\\n return sum([1.0 for key, _ in pred[:k] if key in echt_keys]) / float(k)\",\n \"def precision_at_k(model, ratings, k, relevance_func):\\n predictions = model.predict_all()\\n np.place(predictions, ratings == 0, -np.Inf)\\n recommended = predictions.argsort(1)[::, :-k-1:-1]\\n \\n relevance_per_user = np.take_along_axis(ratings, recommended, 1)\\n max_relevance_per_user = (relevance_per_user > 0).sum(1)\\n relevance_per_user = relevance_func(relevance_per_user).sum(1)\\n\\n precision = np.divide(relevance_per_user, max_relevance_per_user)\\n \\n return np.nanmean(precision)\",\n \"def precision_recall_at_k(predictions, k=10, threshold=3.5):\\r\\n\\r\\n # First map the predictions to each user.\\r\\n user_est_true = defaultdict(list)\\r\\n for uid, _, true_r, est, _ in predictions:\\r\\n user_est_true[uid].append((est, true_r))\\r\\n\\r\\n precisions = dict()\\r\\n recalls = dict()\\r\\n for uid, user_ratings in user_est_true.items():\\r\\n\\r\\n # Sort user ratings by estimated value\\r\\n user_ratings.sort(key=lambda x: x[0], reverse=True)\\r\\n\\r\\n # Number of relevant items\\r\\n n_rel = sum((true_r >= threshold) for (_, true_r) in user_ratings)\\r\\n\\r\\n # Number of recommended items in top k\\r\\n n_rec_k = sum((est >= threshold) for (est, _) in user_ratings[:k])\\r\\n\\r\\n # Number of relevant and recommended items in top k\\r\\n n_rel_and_rec_k = sum(((true_r >= threshold) and (est >= threshold))\\r\\n for (est, true_r) in user_ratings[:k])\\r\\n\\r\\n # Precision@K: Proportion of recommended items that are relevant\\r\\n # When n_rec_k is 0, Precision is undefined. We here set it to 0.\\r\\n\\r\\n precisions[uid] = n_rel_and_rec_k / n_rec_k if n_rec_k != 0 else 0\\r\\n\\r\\n # Recall@K: Proportion of relevant items that are recommended\\r\\n # When n_rel is 0, Recall is undefined. We here set it to 0.\\r\\n\\r\\n recalls[uid] = n_rel_and_rec_k / n_rel if n_rel != 0 else 0\\r\\n\\r\\n return precisions, recalls\",\n \"def precision_at(\\n ks: torch.Tensor, scores: torch.Tensor, labels: torch.Tensor\\n) -> torch.Tensor:\\n\\n ks, scores, labels = _check_inputs(ks, scores, labels)\\n _, _, topk_labels = _extract_topk(ks, scores, labels)\\n precisions = _create_output_placeholder(scores, ks)\\n\\n for index, k in enumerate(ks):\\n precisions[:, index] = torch.sum(topk_labels[:, : int(k)], dim=1) / float(k)\\n\\n return precisions\",\n \"def precision_at_k(r, k = None):\\n assert k is None or k >= 1\\n r = np.asarray(r)[:k] != 0\\n if r.size != k and k is not None:\\n raise ValueError('Relevance score length < k')\\n return np.mean(r)\",\n \"def precision_recall_at_k(predictions, k, threshold):\\n # First map the predictions to each user.\\n user_est_true = defaultdict(list)\\n for uid, _, true_r, est, _ in predictions:\\n user_est_true[uid].append((est, true_r))\\n\\n precisions = dict()\\n recalls = dict()\\n for uid, user_ratings in user_est_true.items():\\n\\n # Sort user ratings by estimated value\\n user_ratings.sort(key=lambda x: x[0], reverse=True)\\n\\n # Number of relevant items\\n n_rel = sum((true_r >= threshold) for (_, true_r) in user_ratings)\\n\\n # Number of recommended items in top k\\n n_rec_k = sum((est >= threshold) for (est, _) in user_ratings[:k])\\n\\n # Number of relevant and recommended items in top k\\n n_rel_and_rec_k = sum(((true_r >= threshold) and (est >= threshold))\\n for (est, true_r) in user_ratings[:k])\\n\\n # Precision@K: Proportion of recommended items that are relevant\\n precisions[uid] = n_rel_and_rec_k / n_rec_k if n_rec_k != 0 else 1\\n\\n # Recall@K: Proportion of relevant items that are recommended\\n recalls[uid] = n_rel_and_rec_k / n_rel if n_rel != 0 else 1\\n\\n # Precision and recall can then be averaged over all users\\n overall_precisions = sum(\\n prec for prec in precisions.values()) / len(precisions)\\n overall_recalls = sum(rec for rec in recalls.values()) / len(recalls)\\n\\n return overall_precisions, overall_recalls\",\n \"def test2_precision_1d(self):\\n arr1 = np.array([0, 1, 1])\\n scores1 = np.array([0.2, 0.3, 0.5])\\n scores1_not_sum_1 = np.array([x * 1542 for x in scores1])\\n\\n k = 1\\n expected_normalized_precision_at_k = 1.0\\n expected_precision_at_k = 1.0\\n\\n actual_normalized = ranking.precision_at_k(y_true=arr1, y_score=scores1, k=k, normalize=True)\\n actual_normalized_not_sum_1 = ranking.precision_at_k(y_true=arr1, y_score=scores1_not_sum_1, k=k,\\n normalize=True)\\n actual = ranking.precision_at_k(y_true=arr1, y_score=scores1, k=k, normalize=False)\\n actual_not_sum_1 = ranking.precision_at_k(y_true=arr1, y_score=scores1_not_sum_1, k=k, normalize=False)\\n\\n self.assertEqual(expected_normalized_precision_at_k, actual_normalized)\\n self.assertEqual(expected_normalized_precision_at_k, actual_normalized_not_sum_1)\\n self.assertEqual(expected_precision_at_k, actual)\\n self.assertEqual(expected_precision_at_k, actual_not_sum_1)\\n\\n k = 2\\n expected_normalized_precision_at_k = 1.0\\n expected_precision_at_k = 1.0\\n\\n actual_normalized = ranking.precision_at_k(y_true=arr1, y_score=scores1, k=k, normalize=True)\\n actual_normalized_not_sum_1 = ranking.precision_at_k(y_true=arr1, y_score=scores1_not_sum_1, k=k,\\n normalize=True)\\n actual = ranking.precision_at_k(y_true=arr1, y_score=scores1, k=k, normalize=False)\\n actual_not_sum_1 = ranking.precision_at_k(y_true=arr1, y_score=scores1_not_sum_1, k=k, normalize=False)\\n\\n self.assertEqual(expected_normalized_precision_at_k, actual_normalized)\\n self.assertEqual(expected_normalized_precision_at_k, actual_normalized_not_sum_1)\\n self.assertEqual(expected_precision_at_k, actual)\\n self.assertEqual(expected_precision_at_k, actual_not_sum_1)\",\n \"def pr_at_k(rels, expected_count, k):\\n k = min(k, len(rels))\\n TP = sum(rels[:k])\\n FP = k - TP\\n FN = expected_count - TP\\n TN = len(rels[k:]) - sum(rels[k:])\\n assert TN >= 0.0\\n return TP / (TP + FP), TP / (TP + FN), TP / (TP + TN) if TP + TN > 0 else 0\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\r\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\r\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\r\\n precision = true_positives / (predicted_positives + K.epsilon())\\r\\n return precision\",\n \"def precision(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def precision(y_true, y_pred):\\r\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\r\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\r\\n precision = true_positives / (predicted_positives + K.epsilon())\\r\\n return precision\",\n \"def precision(y_true, y_pred):\\r\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\r\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\r\\n precision = true_positives / (predicted_positives + K.epsilon())\\r\\n return precision\",\n \"def precision(y_true, y_pred):\\r\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\r\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\r\\n precision = true_positives / (predicted_positives + K.epsilon())\\r\\n return precision\",\n \"def precision(y_true, y_pred):\\r\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\r\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\r\\n precision = true_positives / (predicted_positives + K.epsilon())\\r\\n return precision\",\n \"def precision(y_true, y_pred):\\r\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\r\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\r\\n precision = true_positives / (predicted_positives + K.epsilon())\\r\\n return precision\",\n \"def precision(y_true, y_pred):\\r\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\r\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\r\\n precision = true_positives / (predicted_positives + K.epsilon())\\r\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def M_Precision(y_true, y_pred):\\n\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.constant(K.epsilon()))\\n return precision\",\n \"def retrieval_precision(preds: Tensor, target: Tensor, k: Optional[int]=None, adaptive_k: bool=False) ->Tensor:\\n preds, target = _check_retrieval_functional_inputs(preds, target)\\n if not isinstance(adaptive_k, bool):\\n raise ValueError('`adaptive_k` has to be a boolean')\\n if k is None or adaptive_k and k > preds.shape[-1]:\\n k = preds.shape[-1]\\n if not (isinstance(k, int) and k > 0):\\n raise ValueError('`k` has to be a positive integer or None')\\n if not target.sum():\\n return tensor(0.0, device=preds.device)\\n relevant = target[preds.topk(min(k, preds.shape[-1]), dim=-1)[1]].sum().float()\\n return relevant / k\",\n \"def keras_precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def average_precision_at_k(targets, ranked_predictions, k=None):\\n if k:\\n ranked_predictions = ranked_predictions[:k]\\n score = 0.0\\n hits = 0.0\\n for i, pred in enumerate(ranked_predictions):\\n if pred in targets and pred not in ranked_predictions[:i]:\\n hits += 1.0\\n score += hits / (i + 1.0)\\n divisor = min(len(targets), k) if k else len(targets)\\n return score / divisor\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def precision(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def cdf(self, k):\\n\\n if k < 0 or k > self.n:\\n return 0\\n\\n k = int(k)\\n ans = 0\\n for i in range(0, k + 1):\\n ans += self.pmf(i)\\n return ans\",\n \"def getPrecision(y_true, y_pred):\\r\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\r\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\r\\n precision = true_positives / (predicted_positives + K.epsilon())\\r\\n return precision\",\n \"def compute_pr_at_k(k, true_labels, test_statistics=None, pvalues=None):\\n if (test_statistics is not None) and (pvalues is not None):\\n raise ValueError(\\\"You cannot supply both `test_statistics` and `pvalues`.\\\")\\n\\n if test_statistics is not None:\\n res = test_statistics\\n reverse_sorting = True\\n else:\\n res = pvalues\\n reverse_sorting = False\\n\\n label_matrix = np.zeros((len(true_labels), len(true_labels)))\\n c1 = (true_labels == 0).sum()\\n label_matrix[:c1, :c1] = 1\\n\\n triu_idx = np.triu_indices_from(res, k=1)\\n labels_vec = label_matrix[triu_idx]\\n res_vec = res[triu_idx]\\n\\n idx = np.argsort(res_vec)\\n if reverse_sorting:\\n idx = idx[::-1]\\n sorted_labels = labels_vec[idx]\\n\\n if isinstance(k, int):\\n ks = range(1, k + 1)\\n else:\\n ks = k\\n\\n precisions = [sorted_labels[:k].mean() for k in ks]\\n recalls = [sorted_labels[:k].sum() / sorted_labels.sum() for k in ks]\\n\\n return precisions, recalls\",\n \"def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:\\n\\n if not nums:\\n return 0\\n\\n if k <= 1:\\n return 0\\n\\n count = 0\\n lo = 0\\n product = 1\\n for hi in range(len(nums)):\\n product *= nums[hi]\\n while product >= k:\\n product /= nums[lo]\\n lo += 1\\n count += hi - lo + 1\\n return count\",\n \"def prf_cal(y_pred,y_true,k):\\r\\n GT=np.sum(y_true[y_true==1.])\\r\\n instance_num=y_true.shape[0]\\r\\n prediction_num=instance_num*k\\r\\n\\r\\n sort_indices = np.argsort(y_pred)\\r\\n sort_indices=sort_indices[:,::-1]\\r\\n static_indices = np.indices(sort_indices.shape)\\r\\n sorted_annotation= y_true[static_indices[0],sort_indices]\\r\\n top_k_annotation=sorted_annotation[:,0:k]\\r\\n TP=np.sum(top_k_annotation[top_k_annotation==1.])\\r\\n recall=TP/GT\\r\\n precision=TP/prediction_num\\r\\n f1=2.*recall*precision/(recall+precision)\\r\\n return precision, recall, f1\",\n \"def apk(y_true, y_pred, k):\\n \\n # initialize p@k list of values\\n pk_values = []\\n \\n # loop over all k. from 1 to k+1\\n for i in range(1, k + 1):\\n # calculate p@i and append to list\\n pk_values.append(pk(y_true, y_pred, i))\\n \\n # if we have no values in the list, return 0\\n if len(pk_values) == 0:\\n return 0\\n # else, we return the sum of list over length of list\\n return sum(pk_values) / len(pk_values)\",\n \"def mapk(actual, predicted, k):\\n return round(np.mean([apk(a,p,k) for a,p in zip(actual, predicted)]), 4) * 100\",\n \"def __init__(self, k=10, cutoff=0.5):\\n if k < 0:\\n raise ValueError('k must be positive')\\n super(Precision, self).__init__()\\n self.k = k\\n self.cutoff = cutoff\",\n \"def _K(s):\\n p = 0\\n for k in range(-10, 10, 1):\\n p += (-1)**k * np.exp(-2 * k**2 * s**2)\\n return p\",\n \"def ensure_positive_precision(K):\\n K_diag = np.diag(np.diag(K))\\n K = np.where(np.any(np.diag(K) < 0), np.where(K_diag < 0, 1e-2, K_diag), K)\\n return K\",\n \"def _compute_parameters(self, p, k):\\n for i in range(self._.d + 1):\\n p[0, i, i] = k[i]\\n p[i, 0, i] = Integer(1)\\n p[i, i, 0] = Integer(1)\\n for i in range(self._.d):\\n p[i+1, 1, i+1] = self._.a[i+1]\\n p[i, 1, i+1] = self._.b[i]\\n p[i+1, 1, i] = self._.c[i+1]\\n for i in range(2, self._.d + 1):\\n for j in range(1, self._.d + 1):\\n for h in range(1, self._.d):\\n p[h, i, j] = self._check_parameter(\\n h, i, j,\\n _simplify(_expand((\\n self._.c[h] * p[h-1, i-1, j]\\n + self._.b[h] * p[h+1, i-1, j]\\n - self._.b[i-2] * p[h, i-2, j]\\n + (self._.a[h] - self._.a[i-1]) * p[h, i-1, j]\\n ) / self._.c[i])))\\n p[self._.d, i, j] = self._check_parameter(\\n self._.d, i, j,\\n _simplify(_expand((\\n self._.c[self._.d] * p[self._.d-1, i-1, j]\\n - self._.b[i-2] * p[self._.d, i-2, j]\\n + (self._.a[self._.d] - self._.a[i-1])\\n * p[self._.d, i-1, j]\\n ) / self._.c[i])))\",\n \"def _calculate_probability(self,k):\\n\\t\\tif abs(k * self.delta_x) > (3 * np.sqrt(self.variance)):\\n\\t\\t\\treturn 0.0\\n\\t\\tbinom_coeff = special.binom(self.n,(self.n + k)/2)\\n\\t\\tb_value = binom_coeff * ((self.p) ** ((self.n + k)/2)) * ((1-self.p) ** ((self.n - k)/2))\\n\\t\\treturn b_value\",\n \"def kx(self, k: int) -> float:\\n result = self._read_inline(f\\\"kx({k})\\\")\\n return result\",\n \"def pmf(self, k):\\n\\n if k < 0 or k > self.n:\\n return 0\\n\\n k = int(k)\\n\\n c = (Binomial.factorial(self.n)) / \\\\\\n (Binomial.factorial(k) * self.factorial((self.n - k)))\\n\\n return c * pow(self.p, k) * pow((1 - self.p), (self.n - k))\",\n \"def probability(n, k, p):\\n prob = 0\\n power = expotentation_by_squaring((1-p), n)\\n count_mult = math.log(n, 2)\\n p_fraction = p/(1-p)\\n count_mult += 1\\n for i in range(0, k+1):\\n element = newton(n, i)*power\\n prob += element\\n power *= p_fraction\\n count_mult += 2\\n return prob, count_mult\",\n \"def precision(y_true, y_pred):\\n true_positives = bk.sum(bk.round(bk.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = bk.sum(bk.round(bk.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + bk.epsilon())\\n return precision\",\n \"def recall_at_k(self, positions, k, num_samples):\\n return 1.0 * sum(i <= k for i in positions) / num_samples\",\n \"def params_to_precision(kernel):\\n\\n return kernel.precision()\",\n \"def pkscore(labels, preds, k=10):\\n # Remove padding from labels and preds\\n mask = np.where(labels<=1, True, False)\\n labels = labels[mask]\\n preds = preds[mask]\\n\\n num_windows = len(labels) - k + 1\\n assert num_windows>0, 'Choose a smaller k value'\\n\\n correct = 0\\n for i in range(num_windows):\\n # calculate index of window close\\n j = i + k\\n\\n # Get number of segment splits in labels and preds\\n label_diff = sum(labels[i:j])\\n pred_diff = sum(preds[i:j])\\n\\n # Check for agreement between labels and preds\\n if (label_diff and pred_diff) or (not label_diff and not pred_diff):\\n correct += 1\\n return 1-(correct/(num_windows))\",\n \"def queryPrecision(self, query_doc_IDs_ordered, query_id, true_doc_IDs, k):\\n\\n\\t\\tprecision = -1\\n\\n\\t\\t#Fill in code here\\n\\t\\trel_ret = 0 # no. of relevant docs retrieved\\n\\n\\t\\tfor docID in query_doc_IDs_ordered[:k]:\\n\\t\\t\\tif docID in true_doc_IDs:\\n\\t\\t\\t\\trel_ret += 1\\n\\n\\t\\tprecision = rel_ret/k\\n\\n\\t\\treturn precision\",\n \"def expected_jk_variance(K):\\r\\n\\r\\n kf = float(K)\\r\\n return ((1 / kf) * (kf - 1) / (kf - 0.5) *\\r\\n ((kf - 1) / (kf - 2)) ** 2 * (kf - 3) / (kf - 2))\",\n \"def test_approximate_gamma(self, k):\\n mean_column = prior.PriorParams.field_index(\\\"mean\\\")\\n var_column = prior.PriorParams.field_index(\\\"var\\\")\\n x = self.priors[self.n][k][mean_column]\\n xvar = self.priors[self.n][k][var_column]\\n # match mean/variance\\n alpha_0, beta_0 = approximate_gamma_mom(x, xvar)\\n ck_x = alpha_0 / beta_0\\n ck_xvar = alpha_0 / beta_0**2\\n assert np.isclose(x, ck_x)\\n assert np.isclose(xvar, ck_xvar)\\n # match approximate sufficient statistics\\n logx, _, _ = approx.approximate_log_moments(x, xvar)\\n alpha_1, beta_1 = approx.approximate_gamma_kl(x, logx)\\n ck_x = alpha_1 / beta_1\\n ck_logx = hypergeo._digamma(alpha_1) - np.log(beta_1)\\n assert np.isclose(x, ck_x)\\n assert np.isclose(logx, ck_logx)\\n # compare KL divergence between strategies\\n kl_0 = kl_divergence(\\n lambda x: conditional_coalescent_pdf(x, self.n, k),\\n lambda x: scipy.stats.gamma.logpdf(x, alpha_0, scale=1 / beta_0),\\n )\\n kl_1 = kl_divergence(\\n lambda x: conditional_coalescent_pdf(x, self.n, k),\\n lambda x: scipy.stats.gamma.logpdf(x, alpha_1, scale=1 / beta_1),\\n )\\n assert kl_1 < kl_0\",\n \"def topk_accuracies(preds, labels, ks):\\n num_topks_correct = topks_correct(preds, labels, ks)\\n return [(x / preds.size(0)) * 100.0 for x in num_topks_correct]\",\n \"def precision_on_1(y_true, y_pred):\\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + K.epsilon())\\n return precision\",\n \"def pmf(self, k):\\n if k % 1 != 0:\\n k = int(k)\\n if k < 0 and k <= self.n:\\n return 0\\n q = 1 - self.p\\n co = (self.factorial(self.n) / ((self.factorial(self.n-k)\\n * self.factorial(k))))\\n q2 = q ** (self.n - k)\\n return co * (self.p ** k) * q2\",\n \"def C(n,k):\\n if 0 <= k <= n:\\n ntok = 1\\n ktok = 1\\n for t in xrange(1, min(k, n - k) + 1):\\n ntok *= n\\n ktok *= t\\n n -= 1\\n return ntok // ktok\\n else:\\n return 0\",\n \"def f1_score_at_k(r, max_rel, k = None):\\n p = precision_at_k(r, k)\\n r = recall_at_k(r, max_rel, k)\\n return 2 * p * r / (p + r)\",\n \"def calPFP(n, m, k):\\n return pow(1-math.exp(-k*(n+0.5)/(m-1)), k)\",\n \"def kepler(x, k=1.0):\\n assert(x.shape[2] == 1)\\n\\n q,p = extract_q_p(x)\\n # The derivative of r wrt q is 1/sqrt(sum(q^2)), which is singular in 0.\\n # Cutoff r so that it is > eps.\\n eps = 1e-5\\n r = tf.sqrt(tf.reduce_sum(tf.square(q), axis=1) + eps)\\n return tf.squeeze(0.5 * tf.reduce_sum(tf.square(p), axis=1) + k / r)\",\n \"def superobl_p(k):\\n if k%2==0:\\n return 1/2 + 1/(2*(k+1))\\n else:\\n return 1/2 + 1/(2*k)\",\n \"def choose(n, k):\\r\\n if 0 <= k <= n:\\r\\n ntok = 1\\r\\n ktok = 1\\r\\n for t in range(1, min(k, n - k) + 1):\\r\\n ntok *= n\\r\\n ktok *= t\\r\\n n -= 1\\r\\n return ntok // ktok\\r\\n else:\\r\\n return 0\",\n \"def test_kpa_conversion(self):\\n\\n result = get_kpa(5.6, 25)\\n\\n self.assertTrue(result == -34.281679)\",\n \"def pow_derpy(x, k):\\n if k == 1:\\n return x\\n if k == 0:\\n return 1\\n\\n return x * pow_derpy(x, k - 1)\",\n \"def k_rank_approximate(doc_matrix, k):\\n return []\",\n \"def n_choose_k(n: int, k: int) -> int:\\n # Edge case, no possible way to choose.\\n if k > n or k < 0 or n < 0: return 0\\n # We choose the min of k or n - k\\n # since nCk == nC(n - k).\\n k = min(k, n - k)\\n # The numerator represents the product\\n # n * (n - 1) * (n - 2) * ... * (n - k - 1)\\n numerator = reduce(mul, range(n, n - k, -1), 1)\\n # The denominator represents the product\\n # 1 * 2 * ... * k\\n denominator = reduce(mul, range(1, k + 1), 1)\\n # return the result as an integer.\\n return numerator // denominator\",\n \"def precisions(self):\\n raise NotImplementedError\",\n \"def get_precision(self):\\n ...\",\n \"def pk(y_true, y_pred, k):\\n \\n # if k is 0, return 0. we should never have this\\n # as k is always >= 1\\n if k == 0:\\n return 0\\n # we are interested only in top-k predictions\\n y_pred = y_pred[:k]\\n \\n # convert predictions to set\\n pred_set = set(y_pred)\\n \\n # convert actual values to set\\n true_set = set(y_true)\\n \\n # find common values\\n common_values = pred_set.intersection(true_set)\\n \\n # return length of common values over k\\n return len(common_values) / len(y_pred[:k])\",\n \"def ranking_precision_score(y_true, y_score, k=10):\\n unique_y = np.unique(y_true)\\n\\n if len(unique_y) > 2:\\n raise ValueError(\\\"Only supported for two relevance levels.\\\")\\n\\n n_relevant = 0\\n n_pos = 0\\n for relevance_score in y_true:\\n if relevance_score == 1:\\n n_pos += 1\\n\\n for index in y_score[:k]:\\n if y_true[index] == 1:\\n n_relevant += 1\\n\\n # Divide by min(n_pos, k) such that the best achievable score is always 1.0.\\n return float(n_relevant) / min(n_pos, k) if min(n_pos, k) > 0 else 0\",\n \"def kpdf(t,c,tau,k):\\n return k*(1-st.gamma.cdf(t,c,loc=0,scale=tau))+(1-k*t)*st.gamma.pdf(t,c,loc=0,scale=tau)\",\n \"def __init__(self, k=10, cutoff=0.5):\\n if k < 0:\\n raise ValueError('k must be positive')\\n super(PrecisionLower, self).__init__(k, cutoff)\",\n \"def precision(classifier_output, true_labels):\\n\\n # TODO: finish this.\\n conf_matrix = confusion_matrix(classifier_output, true_labels)\\n return conf_matrix[0][0]/(conf_matrix[0][0] + conf_matrix[1][0])\",\n \"def precision_m(self, y_true, y_pred):\\n true_positives = keras.backend.sum(keras.backend.round(keras.backend.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = keras.backend.sum(keras.backend.round(keras.backend.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + keras.backend.epsilon())\\n return precision\",\n \"def nCk(n, k):\\n return factorial(n)//factorial(k)//factorial(n-k)\",\n \"def precision(y_true, y_pred):\\n true_positives = backend.sum(backend.round(backend.clip(y_true * y_pred, 0, 1)))\\n predicted_positives = backend.sum(backend.round(backend.clip(y_pred, 0, 1)))\\n precision = true_positives / (predicted_positives + backend.epsilon())\\n return precision\",\n \"def calc(k):\\n n = factorial(4*k) * (1103.0 + 26390.0*k)\\n d = factorial(k)**4 * 396.0**(4.0*k)\\n z = n/d\\n return z\",\n \"def __init__(self, k=10, cutoff=0.5):\\n if k < 0:\\n raise ValueError('k must be positive')\\n super(PrecisionUpper, self).__init__(k, cutoff)\",\n \"def mean_avg_prec_at_k(question_set, candidate_set, k=None):\\n # TODO(umaroy): add test for this method on a known set of encodings.\\n # Current run_xreqa_eval.sh with X_Y encodings generates mAP of 0.628.\\n all_questions = question_set.as_list()\\n all_candidates = candidate_set.as_list()\\n for embedding_type in ['sentences_and_contexts']:\\n candidate_matrix = np.concatenate(\\n [np.expand_dims(i.encoding[embedding_type], 0) for i in all_candidates],\\n axis=0)\\n\\n ap_scores = []\\n for q in all_questions:\\n question_vec = np.expand_dims(q.encoding, 0)\\n scores = question_vec.dot(candidate_matrix.T)\\n y_true = np.zeros(scores.shape[1])\\n all_correct_cands = set(candidate_set.by_xling_id[q.xling_id])\\n for ans in all_correct_cands:\\n y_true[candidate_set.pos[ans]] = 1\\n ap_scores.append(average_precision_at_k(\\n np.where(y_true == 1)[0], np.squeeze(scores).argsort()[::-1], k))\\n print(embedding_type + \\\": \\\" + str(np.mean(ap_scores)))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76427615","0.74189496","0.7418079","0.72710466","0.72456723","0.72446615","0.7237539","0.72213703","0.7210107","0.7058935","0.6852219","0.6786084","0.67836976","0.6768417","0.67273885","0.67181736","0.67181736","0.67181736","0.67181736","0.67181736","0.67181736","0.67165935","0.67165935","0.67165935","0.67165935","0.67165935","0.67165935","0.67165935","0.67165935","0.67165935","0.67089933","0.66921306","0.66757774","0.66481805","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.66469735","0.6637747","0.6631698","0.65775067","0.6533178","0.6527984","0.65041053","0.6500147","0.6457458","0.6433143","0.63926375","0.6376261","0.63702464","0.63491803","0.63410544","0.6314881","0.6307336","0.62782466","0.6258641","0.62575054","0.62385947","0.6232881","0.62196195","0.61937124","0.61900115","0.61764354","0.6156905","0.61399555","0.61389506","0.6136565","0.61267686","0.61231154","0.61223644","0.61219835","0.61058086","0.6096785","0.6091392","0.60853106","0.6082413","0.6075436","0.60727143","0.60661167","0.60641485","0.6061439","0.60593694","0.6053266","0.602791","0.60272074","0.6020167"],"string":"[\n \"0.76427615\",\n \"0.74189496\",\n \"0.7418079\",\n \"0.72710466\",\n \"0.72456723\",\n \"0.72446615\",\n \"0.7237539\",\n \"0.72213703\",\n \"0.7210107\",\n \"0.7058935\",\n \"0.6852219\",\n \"0.6786084\",\n \"0.67836976\",\n \"0.6768417\",\n \"0.67273885\",\n \"0.67181736\",\n \"0.67181736\",\n \"0.67181736\",\n \"0.67181736\",\n \"0.67181736\",\n \"0.67181736\",\n \"0.67165935\",\n \"0.67165935\",\n \"0.67165935\",\n \"0.67165935\",\n \"0.67165935\",\n \"0.67165935\",\n \"0.67165935\",\n \"0.67165935\",\n \"0.67165935\",\n \"0.67089933\",\n \"0.66921306\",\n \"0.66757774\",\n \"0.66481805\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.66469735\",\n \"0.6637747\",\n \"0.6631698\",\n \"0.65775067\",\n \"0.6533178\",\n \"0.6527984\",\n \"0.65041053\",\n \"0.6500147\",\n \"0.6457458\",\n \"0.6433143\",\n \"0.63926375\",\n \"0.6376261\",\n \"0.63702464\",\n \"0.63491803\",\n \"0.63410544\",\n \"0.6314881\",\n \"0.6307336\",\n \"0.62782466\",\n \"0.6258641\",\n \"0.62575054\",\n \"0.62385947\",\n \"0.6232881\",\n \"0.62196195\",\n \"0.61937124\",\n \"0.61900115\",\n \"0.61764354\",\n \"0.6156905\",\n \"0.61399555\",\n \"0.61389506\",\n \"0.6136565\",\n \"0.61267686\",\n \"0.61231154\",\n \"0.61223644\",\n \"0.61219835\",\n \"0.61058086\",\n \"0.6096785\",\n \"0.6091392\",\n \"0.60853106\",\n \"0.6082413\",\n \"0.6075436\",\n \"0.60727143\",\n \"0.60661167\",\n \"0.60641485\",\n \"0.6061439\",\n \"0.60593694\",\n \"0.6053266\",\n \"0.602791\",\n \"0.60272074\",\n \"0.6020167\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":7399,"cells":{"query":{"kind":"string","value":"Calculate Equal Error Rate (EER)."},"document":{"kind":"string","value":"def calculate_eer(y, y_score, pos=1):\n fpr, tpr, thresholds = roc_curve(y, y_score, pos_label=pos)\n eer = brentq(lambda x: 1. - x - interp1d(fpr, tpr)(x), 0., 1.)\n thresh = interp1d(fpr, thresholds)(eer)\n return eer, np.float(thresh)"},"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 calculate_hr_ee(self):\n\n # HR - resting HR = net HR\n net_hr = np.array([i - self.rest_hr if i is not None else None for i in self.df_epoch[\"HR\"]])\n\n # Sets values below 0% HRR (below resting HR) to 0\n net_hr[net_hr <= 0] = 0\n\n # Equation from Brage et al., 2004. Active EE in kJ/kg/min\n kj_kg_min = [.011 * (hr ** 2) + 5.82 * hr if hr is not None else None for hr in net_hr]\n\n # Converts kJ to kcal: relative EE (kcal/kg/min)\n kcal_kg_min = [k / 4.184 if k is not None else None for k in kj_kg_min]\n\n # Converts relative EE to absolute EE (kcal/min)\n kcal_min = [k * self.weight / 1000 if k is not None else None for k in kcal_kg_min]\n\n # kcals per epoch instead of per minute\n kcal_epoch = [k * (15 / 60) for k in kcal_min]\n\n total_ee = sum([i for i in kcal_epoch if not np.isnan(i)])\n print(\"-Total energy expenditure estimated from HR is {} kcal.\".format(int(total_ee)))\n\n self.df_epoch[\"HR_EE\"] = kcal_min","def rae(self) -> float:\n return float(np.sum(self._ae()) / (np.sum(np.abs(self.true - np.mean(self.true))) + EPS))","def diff_of_errors(self):\n self.e_of_e = self.azimuth_error - self.altitude_error\n return self.e_of_e","def e(self):\n\n ylow = self.e_min\n yhigh = self._e\n\n xlow = 0\n xhigh = self.anneal_max\n\n steep_mult = 8\n\n steepness = steep_mult / (xhigh - xlow)\n offset = (xhigh + xlow) / 2\n midpoint = yhigh - ylow\n\n x = np.clip(self.avg_score, 0, xhigh)\n x = steepness * (x - offset)\n e = ylow + midpoint / (1 + np.exp(x))\n return e","def compute_EER(self, FAR, FRR):\r\n print('Computing EER')\r\n distance = abs(FAR - FRR)\r\n min_distance = min(distance)\r\n idx = np.where(distance == min_distance)\r\n return np.mean((FAR[idx] + FRR[idx]) / 2)","def test_epe_evaluate(self):\n epe_metric = EPE()\n epe_metric.process(self.data_batch, self.data_samples)\n epe = epe_metric.evaluate(1)\n self.assertAlmostEqual(epe['EPE'], 11.5355339)","def calculate_energy_conservation_error(self):\n assert self.data is not None\n # calculate total energy at start and end of simulation\n energy_start = self.measure_total_energy(self.t0)\n energy_end = self.measure_total_energy(self.t1)\n \n # calculate accuracy\n error = abs(1.0 - energy_start/energy_end)\n \n return error","def _calc_Em(self):\n return (self.parameters.E0 +\n self.x * sqrt2 * self.parameters.sigma * self.mt)","def ivrmse(self):\n return (self.model_error_iv()**2).mean()**.5","def e(self):\n if self._e is None:\n # self._e = self.distributions.uniform(0.3,0.33)\n # return self._e\n # max is set by q but also limited by users choice of e_max.\n res_a = 29.9*((self.j[0]/self.k[0])**(2/3))\n q = self.distributions.truncated_normal(self.q_c, self.q_w, res_a*(1-0.8), res_a*(1-0.001))\n self._e = 1 - q/res_a\n return self._e","def erf(data):\n return _make.erf(data)","def _calculate_measurement_error(self): \n \n # Calculate Hartmann Spot\n # FIXME what are factor_1, factor_2 ???\n factor_1, factor_2 = 206265*5.89e-7, 206265*6.5e-7\n term1, term2 = factor_1/self.actuator_spacing, factor_2/self.r0\n hartmann_spot = np.max([term1, term2])\n \n # Calculate SNR \n n_pix=4 # FIXME spreadsheet says not to change this idk why?\n sample_time = 1/(10*self.controller_frequency)\n brightness = (8.9e5)*10**((0-self.guide_star_mag)/2.5)\n n_photons = brightness*sample_time*((100*self.actuator_spacing)**2)\n snr = n_photons/np.sqrt(n_photons + n_pix*(self.sigma_readnoise)**2)\n\n # Calculate noise propagator \n degrees_of_freedom = np.round((np.pi/4) * (self.telescope_diameter/self.actuator_spacing)**2)\n factor_1, factor_2 = 0.0536, 0.0795 # FIXME WHAT THE HECK IS THIS\n if self.aperture == 'circular':\n factor_1, factor_2 = 0.0068, 0.0796\n noise_propagator = np.sqrt(2*(factor_1 + factor_2*np.log(degrees_of_freedom)))\n\n # Calculate close loop averaging\n controller_over_frame = 1/10\n close_loop_averaging = np.sqrt(2*controller_over_frame)*np.arctan(1/(2*controller_over_frame))\n sigma_measurement = noise_propagator * close_loop_averaging * (self.actuator_spacing*1e9) * (hartmann_spot/snr*4.84814e-6)\n self.sigma_measurement = sigma_measurement # in nm","def eccentricAnomaly(e, M):\n E = M if e < 0.8 else math.pi\n \n F = E - e*math.sin(M) - M\n for i in range(100):\n E = E - F/(1.0-e*math.cos(E))\n F = E - e*math.sin(E) - M\n if math.fabs(F)<1e-16:\n break\n E = mod2pi(E)\n return E","def compute_RMSE(e):\n \"\"\"Corresponds to sqrt(2*MSE)\"\"\"\n \n return np.sqrt(2*compute_MSE(e))","def emissivity_profile(R):\n E = R**(-3.0)*(1 - (R_in/R)**(1.0/2.0))\n return E","def get_E(self):\r\n return self.Real.E, self.Ideal.E","def get_E(self):\r\n return self.Real.E, self.Ideal.E","def calculate_error(self):\n \n delta = self.Y - self.T\n error = delta.dot(delta) / self.N\n error = format(error, '.5f')\n \n self.errors.append(error)","def euler_error(Rd, Re):\n\n nd = Rd[:, 0]\n sd = Rd[:, 1]\n ad = Rd[:, 2]\n\n ne = Re[:, 0]\n se = Re[:, 1]\n ae = Re[:, 2]\n\n return 0.5 * (np.cross(ne, nd) + np.cross(se, sd) + np.cross(ae, ad)) # eqn 3.85","def adjust_E(self, power):\n if self.pwr_in_tot:\n fac = power/self.pwr_in_tot\n else:\n fac = 1.0\n fac = min(1.01, fac)\n self.Ey = sqrt(fac)*self.Ey","def test_exponential_answer(self):\r\n answer = 50\r\n correct_responses = [\r\n \"50\", \"50.0\", \"5e1\", \"5e+1\",\r\n \"50e0\", \"50.0e0\", \"500e-1\"\r\n ]\r\n incorrect_responses = [\"\", \"3.9\", \"4.1\", \"0\", \"5.01e1\"]\r\n\r\n for input_str in correct_responses:\r\n result = calc.evaluator({}, {}, input_str)\r\n fail_msg = \"Expected '{0}' to equal {1}\".format(\r\n input_str, answer\r\n )\r\n self.assertEqual(answer, result, msg=fail_msg)\r\n\r\n for input_str in incorrect_responses:\r\n result = calc.evaluator({}, {}, input_str)\r\n fail_msg = \"Expected '{0}' to not equal {1}\".format(\r\n input_str, answer\r\n )\r\n self.assertNotEqual(answer, result, msg=fail_msg)","def energy(e: float) -> float:\n\n return (1/np.sqrt(2))*(gamma(-e/2+1/2)/(gamma(-e/2+3/4)))","def mrae(self, benchmark: np.ndarray = None):\n return float(np.mean(np.abs(self._relative_error(benchmark))))","def calcEout(model_type): \n b, v = calcStatistics(model_type)\n return b + v","def get_e(self):\n return self.e_min + self.e_ * self.e_range","def inrse(self) -> float:\n return float(np.sqrt(np.sum(np.square(self._error())) / np.sum(np.square(self.true - np.mean(self.true)))))","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])**2\n # id-isolation\n unc += (self._eleIdIsoWeight[(e1.pt(),e1.eta())][1]/self._eleIdIsoWeight[(e1.pt(),e1.eta())][0] + \\\n self._eleIdIsoWeight[(e2.pt(),e2.eta())][1]/self._eleIdIsoWeight[(e2.pt(),e2.eta())][0])**2\n # trigger (approximate)\n unc += (abs(self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][1]+ \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][1]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][1]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]- \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][1])/ \\\n (self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]))**2\n unc += ((self._ele8TrgWeight[(e1.pt(),e1.eta())][1]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][1])/ \\\n (self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]))**2\n #outcome\n return sqrt(unc)","def calculate_wrist_ee(self):\n\n data = [i * (30 / 75) for i in self.df_epoch[\"LWrist\"]]\n\n # Modified equation from Powell et al. 2017. Removed resting component (constant = 1.15451)\n mets = [.022261 * i for i in data]\n\n # Converts METs to relative VO2 (mL O2/kg/min)\n r_vo2 = [3.5 * m for m in mets]\n\n # Converts relative VO2 to absolute VO2 (L O2/kg/min)\n a_vo2 = [i * self.weight / 1000 for i in r_vo2]\n\n # Converts absolute VO2 to kcal/min (assumes 1 L O2 -> 4.825 kcal)\n kcal_min = [a * 4.825 for a in a_vo2]\n\n # Calculates kcal/epoch\n kcal_epoch = [k * (15 / 60) for k in kcal_min]\n\n total_ee = sum([i for i in kcal_epoch if not np.isnan(i)])\n print(\"-Total energy expenditure estimated from Wrist is {} kcal.\".format(int(total_ee)))\n\n self.df_epoch[\"Wrist_EE\"] = kcal_min","def E(self, dstrct):\n rep_votes = dstrct.rep_votes + self.properties['sen_red']\n dem_votes = dstrct.dem_votes + self.properties['sen_blue']\n\n thresh = threshold(rep_votes+dem_votes)\n rep_wasted = wasted_votes(rep_votes, thresh)\n dem_wasted = wasted_votes(dem_votes, thresh)\n gap = (rep_wasted - dem_wasted)/(rep_votes + dem_votes)\n score = 1-abs(gap)\n\n self.E_ = self.w_E * score\n return self.E_","def rmse(self):\n return (self.model_error()**2).mean()**.5","def E(self):\n return self.generic_getter(get_energy, \"E\", \"convert_energy\")","def get_error_rates():\n return [ERR_RT * i for i in range(int((1 / ERR_RT) / 4))] # error up to 25%","def ErrorCorrect(val,fEC):\n return val * fEC","def compute_MSE(e):\n\n return 1/2*np.mean(e**2)","def get_R_e(E, M, g_e, T_e):\n # transform energy-vector into matrices\n mat_E_x, mat_E_y = np.meshgrid(E,E) \n mat_diff = mat_E_y - mat_E_x # matrix representing: E_i - E_j\n R_e = np.ones((M,M))*g_e**2 * T_e # matrix for transition rates\n ind = np.abs(mat_diff) > 0 # indices of the non-divergent elements\n # fill in just those elements without divergences 1/0\n # the rest is set to the correct limit\n R_e[ind] = g_e**2 * mat_diff[ind]/(np.exp(mat_diff[ind]/T_e)-1)\n return R_e","def calculate_exponent():\n pass","def mean_error(self) -> float:\n self.ME = sum(np.array(self.sim_data[\"Human (mean)\"]) - np.array(self.sim_data[\"assigned_sim\"])) / len(self.sim_data)\n return self.ME","def calculate_mse(e):\r\n return 1/2*np.mean(e**2)","def rrse(self) -> float:\n return float(np.sqrt(self.rse()))","def error(self, trainset: ([], [])):\n # MSE = Σ | d – y |^2 / n\n error_sum = 0.0\n for index, example in enumerate(trainset):\n # | d – y |^2\n output = self.activate(example[0])\n\n target = example[1][0]\n\n error = target - output\n error_sum += error ** 2\n\n # Σ |error_sum| / n\n error_sum = error_sum / len(trainset)\n return error_sum","def energy(self):\n e = 0\n\n restoration = RestorationModel(self.graph_damaged)\n restoration.run(self.state)\n restoration_graphs = restoration.get_restoration_graphs()\n restoration_times = restoration.get_restoration_times()\n restoration_costs = restoration.get_restoration_costs()\n\n damaged = []\n damaged.append(get_delta(self.no_damage, self.initial_damage))\n\n sim_results = Parallel(n_jobs=4)(delayed(parallel_model)(\n graph, self.od_graph, self.od_matrix) for graph in restoration_graphs[:-1])\n for values in sim_results:\n damaged.append(get_delta(self.no_damage, values))\n\n for idx, values in enumerate(damaged):\n dt = restoration_times[idx] if idx == 0 else restoration_times[idx] - \\\n restoration_times[idx-1]\n e += sum(restoration_costs[idx]) + dt * (self.day_factor * values[2] * np.sum(self.mu*self.xi) +\n values[3] * np.sum(self.mu * (self.nu * self.F_w + self.rho)) + values[4] * self.upsilon)\n with open(self.fdir+'energy.csv', 'a') as f:\n f.write('\\n'+str(e))\n\n return e","def Eee(h_in, h_out, neutron_spectrum):\n h_out.Scale(0.098)\n neutron_spectrum.Add(h_in, 1)\n neutron_spectrum.Add(h_out, -1)\n neutron_spectrum.Fit('gaus')\n #neutron_spectrum.Draw()\n #input()\n results_fit = neutron_spectrum.GetFunction('gaus')\n mean_energy = results_fit.GetParameter(1)\n spread_energy = results_fit.GetParError(1)\n return mean_energy, spread_energy","def _Ep(self):\n return np.logspace(np.log10(self.Epmin.to('GeV').value),np.log10(self.Epmax.to('GeV').value),\n self.nEpd * (np.log10(self.Epmax/self.Epmin)))","def eccentricity(self):\n return self.b / self.a","def delta_energy(atom,layer1,layer2):\n global r,c,h\n return float('%.2E' % Decimal(str(r*((atom**2/layer1**2)-(atom**2/layer2**2)))))","def calculateErrorRate(numCorrect, numWrong):\n return np.round((numWrong)/(numCorrect+numWrong),3)","def mbe(self) -> float:\n return float(np.mean(self._error(self.true, self.predicted)))","def erf(x):\n return 0.0","def E_fermi(n_e):\n return n_e / nu0 # in K","def Hydrogen_Rate(E):\n\treturn (4.0/E)*np.exp(-(2.0/3.0)/E)","def calculate_improved_euler(self, delta_time=0.02, iterations=100):\n predator_history = []\n prey_history = []\n print self.predators\n print self.prey\n predator_history.append(self.predators)\n prey_history.append(self.prey)\n print predator_history\n print prey_history\n harvesting_effort_history = []\n print self.prey\n for i in range(iterations):\n xk_1 = self.prey_change(self.prey, self.predators) * delta_time\n yk_1 = self.predator_change(self.prey, self.predators) * delta_time\n xk_2 = self.prey_change(self.prey + xk_1, self.predators + yk_1) * delta_time\n yk_2 = self.predator_change(self.prey + xk_1, self.predators + yk_1) * delta_time\n\n\n self.prey = self.prey_change(self.prey, self.predators)\n self.predators = self.predator_change(self.prey, self.predators)\n\n predator_history.append(self.predators)\n prey_history.append(self.prey)\n\n return {'predator': predator_history, 'prey': prey_history}","def calc_ema(self):\n emaFactor = self.settings['emaFactor']\n stepFactor = emaFactor ** self.vars['dt']\n if self.vars['step'] == 0:\n ema = float('NaN')\n elif self.vars['step'] == 1:\n ema = self.vars['speed_trace'][1]\n else:\n ema = stepFactor * self.vars['ema_trace'][self.vars['step'] - 1] + (\n 1 - stepFactor)*self.vars['speed_trace'][self.vars['step']]\n return ema","def energy(self):\n nocc, gmo, e = self.nocc, self.gmo, self.e\n\n Ec = 0.0\n for i in range(nocc):\n for j in range(nocc):\n for a in range(nocc, len(e)):\n for b in range(nocc, len(e)):\n Ec += (1/4.0) * gmo[i, j, a, b]**2 / (e[i]+e[j]-e[a]-e[b])\n\n self.Ec = Ec\n self.E_mp2 = Ec + self.E_scf\n\n print('@MP2 correlation energy: {:15.10f}\\n'.format(self.Ec))\n print('@Total MP2 energy: {:15.10f}\\n'.format(self.E_mp2))\n\n return self.E_mp2","def test_mcintosh_e(self):\n c = array([1,2,3,1])\n num = sqrt(15)\n den = sqrt(19)\n exp = num/den\n self.assertEqual(mcintosh_e(c), exp)","def energy_atom(atom,layer):\n global r,c,h\n backval= r*((atom**2/layer**2))\n return float('%.2E' % Decimal(str(backval)))","def _emiss_ep(self,Eph):\n if self.weight_ep == 0.0:\n return np.zeros_like(Eph)\n\n gam = np.vstack(self._gam)\n eps = (Eph / mec2).decompose().value\n # compute integral with electron distribution\n emiss = c.cgs * trapz_loglog(np.vstack(self._nelec) * self._sigma_1(gam,eps),\n self._gam, axis=0).to(u.cm**2 / Eph.unit)\n return emiss","def eccentricity(self):\n new_data = self._data[['pl_pnum', 'pl_orbper', 'pl_orbsmax',\n 'pl_masse', 'pl_orbeccen',\n 'pl_radj', 'pl_dens', 'st_teff',\n 'st_mass', 'st_rad']]\n new_data = new_data.dropna()\n\n features = new_data[['pl_pnum', 'pl_orbper', 'pl_orbsmax',\n 'pl_masse',\n 'pl_radj', 'pl_dens', 'st_teff',\n 'st_mass', 'st_rad']]\n labels = new_data['pl_orbeccen']\n\n features_train, features_test, labels_train, labels_test = \\\n train_test_split(features, labels, test_size=0.2)\n\n # Create an untrained model\n model = DecisionTreeRegressor()\n\n # Train it on the **training set**\n model.fit(features_train, labels_train)\n\n # Compute test accuracy\n test_predictions = model.predict(features_test)\n test_acc = mean_absolute_error(labels_test, test_predictions)\n test_acc_r2 = r2_score(labels_test, test_predictions)\n\n # Plot ML vs Actual\n fig, [ax1, ax2] = plt.subplots(2, figsize=(15, 12))\n\n sns.distplot(test_predictions, kde=False, ax=ax1)\n sns.distplot(labels_test, kde=False, ax=ax2)\n\n ax1.set_title('Distribution of Predicted Eccentricities of Orbits')\n ax1.set_xlabel('Eccentricity of Orbit')\n ax1.set_ylabel('Number of Planets')\n\n ax2.set_title('Distribution of Actual Eccentricities of Orbits')\n ax2.set_xlabel('Eccentricity of Orbit')\n ax2.set_ylabel('Number of Planets')\n\n plt.savefig('figures/ML_Eccentricity.png', bbox_inches='tight')\n\n return (test_acc, test_acc_r2)","def error_compute(self):\n self.tt_error = np.linalg.norm(self.rel_error)\n if self.global_rank==0:print('Overall error is::',self.tt_error)\n return {'NMF': self.rel_error, 'tt': self.tt_error}","def get_E(self):\n return self.E","def energy(self):\n nocc, ntot, gmo, e = self.nocc, self.ntot, self.gmo, self.e\n\n Ec = 0.0\n for i in range(nocc):\n for j in range(nocc):\n for a in range(nocc, ntot):\n for b in range(nocc, ntot):\n Ec += gmo[i, a, j, b]*(2*gmo[i, a, j, b] - gmo[i, b, j, a])/\\\n (e[i] + e[j] - e[a] - e[b])\n\n self.Ec = Ec\n self.E_mp2 = Ec + self.E_scf\n\n print('@MP2 correlation energy: {:15.10f}\\n'.format(self.Ec))\n print('@Total MP2 energy: {:15.10f}\\n'.format(self.E_mp2))\n\n return self.E_mp2","def adjacent_error(self, field, exclude=False):\n\n self.log.info('Running the adjacent error computation for quantity %s', field)\n # If we need to exclude calculate the indices\n if exclude:\n start, end = self.get_slice(self.sims[0])\n excluded = '_excluded'\n else:\n start = 0\n end = None\n excluded = ''\n base = self.sims[0].conf['General']['results_dir']\n errpath = os.path.join(base, 'adjacenterror_%s%s.dat' % (field, excluded))\n with open(errpath, 'w') as errfile:\n self.log.info('Computing adjacent error for sweep %s', base)\n # For all other sims in the groups, compare to best estimate\n # and write to error file\n for i in range(1, self.num_sims):\n # Set reference sim\n ref_sim = self.sims[i]\n # Get the comparison vector\n vecs1, normvec = self.get_comp_vec(ref_sim, field, start, end)\n sim2 = self.sims[i - 1]\n vecs2, normvec2 = self.get_comp_vec(sim2, field, start, end)\n self.log.info(\"Computing adjacent error between numbasis %i and numbasis %i\",\n ref_sim.conf['Simulation'][ 'params']['numbasis'],\n sim2.conf['Simulation']['params']['numbasis'])\n # Get the array containing the magnitude of the difference vector at each point\n # in space\n mag_diff_vec = self.diff_sq(vecs1, vecs2)\n # Check for equal lengths between norm array and diff mag\n # array\n if len(mag_diff_vec) != len(normvec):\n self.log.error(\"The normalization vector has an incorrect number of elements!!!\")\n raise ValueError\n # Error as a percentage should be thkkk square root of the ratio of sum of mag diff vec\n # squared to mag efield squared\n error = np.sqrt(np.sum(mag_diff_vec) / np.sum(normvec))\n # self.log.info(str(error))\n errfile.write('%i,%f\\n' % (sim2.conf['Simulation']['params']['numbasis'], error))\n sim2.clear_data()\n ref_sim.clear_data()","def _emiss_ee(self,Eph):\n if self.weight_ee == 0.0:\n return np.zeros_like(Eph)\n\n gam = np.vstack(self._gam)\n # compute integral with electron distribution\n emiss = c.cgs * trapz_loglog(np.vstack(self._nelec) * self._sigma_ee(gam,Eph),\n self._gam, axis=0)\n return emiss","def computeEnergy(self):\n\t\tGmo = self.Gmo\n\t\te = self.e\n\t\tself.Ec = 0.0\n\n\t\tfor i in range( self.nocc ):\n\t\t\tfor j in range( self.nocc ):\n\t\t\t\tfor a in range( self.nocc,self.norb ):\n\t\t\t\t\tfor b in range( self.nocc,self.norb ):\n\t\t\t\t\t\tself.Ec += 0.25*(Gmo[i,j,a,b]*Gmo[a,b,i,j])/(e[i]+e[j]-e[a]-e[b])\n\n\t\treturn self.E0 + self.Ec","def error_rate(dataset, estimates):\n\tincorrect = 0.0\n\tcount = 0.0\n\n\tfor idx in range(len(estimates)):\n\t\testimate = estimates[idx]\n\t\t_, actual = dataset[idx]\n\t\tfor e, a in zip(estimate, actual):\n\t\t\tcount += 1.0\n\t\t\tif e != a:\n\t\t\t\tincorrect += 1.0\n\t\n\treturn incorrect / count","def mbrae(self, benchmark: np.ndarray = None) -> float:\n return float(np.mean(self._bounded_relative_error(benchmark)))","def Er( z, r, epsilon, k0, w0, wp, t) :\n Er_array = \\\n epsilon * m_e*c**2/e * 2*r/w0**2 * \\\n np.exp( -r**2/w0**2 ) * np.sin( k0*z ) * np.sin( wp*t )\n return( Er_array )","def MSE_one_error(real,estimate):\n error = mean_squared_error(real.T, estimate.T)\n return error","def Eee2(neutron_spectrum):\n neutron_spectrum.Fit('gaus')\n results_fit = neutron_spectrum.GetFunction('gaus')\n mean_energy = results_fit.GetParameter(1)\n spread_energy = results_fit.GetParError(1)\n return mean_energy, spread_energy","def pair_energy(self,e, s, r):\n return 4.0*e*((s/r)**12-(s/r)**6)","def get_error_estimates(self, Y, M1, M2=None):\n # First K0 and K1\n Mminus = M1\n if M2 is None:\n Mplus = M1\n else:\n Mplus = M2\n if self.Cp0 != 0 and self.Cp1 != 0 and self.Cm != 0:\n Cp0 = self.Cp0\n Cp1 = self.Cp1\n Cm = self.Cm\n else:\n PP = self.principal_part()\n Cmax = max(PP.values())\n Kmax = 0\n for t in PP.keys():\n if isinstance(t, tuple):\n (c, l) = t\n elif isinstance(t, (int, Integer)):\n (c, l) = rn_from_D(self._space.multiplier(), t)\n else:\n raise ValueError(\"Incorrect principal part: t={0}\".format(t))\n if c in self._space.multiplier().D():\n tmp = l + self._space.multiplier().Qv[self._space.index_set().index(c)]\n elif c in range(len(self._space.multiplier().Qv)):\n tmp = l + self._space.multiplier().Qv[c]\n else:\n raise ValueError(\"Incorrect principal part: c,l={0},{1}\".format(c, l))\n if(abs(tmp) > Kmax):\n Kmax = abs(tmp)\n [Cp0, Cp1] = self._space.get_Cp(Cmax)\n Cm = self._space.get_Cm(Kmax, Cmax)\n self.Cp0 = Cp0\n self.Cp1 = Cp1\n self.Cm = Cm\n\n fak = len(self._space.index_set())\n # print \"Cp0,Cp1,Cm=\",Cp0,Cp1,Cm\n # print \"fak=\",fak\n\n er1 = fak * self._space.err_est_vv_hwmf_neg(Y, Mminus, Cm)\n er2 = fak * self._space.err_est_vv_hwmf_pos(Y, Mplus, Cp0, Cp1)\n return [er1, er2]","def energy(self, r):\n sigma = self.params['sigma']\n epsilon = self.params['epsilon']\n s = sigma / r\n s6 = s**6; s12 = s6 * s6\n pot = 4.0 * epsilon * (s12 - s6)\n return pot","def gmrae(self, benchmark: np.ndarray = None) -> float:\n return _geometric_mean(np.abs(self._relative_error(benchmark)))","def E(self):\n return self._E","def E(self):\n return self._E","def dependent_error_exp(data, weak_signal_data, num_weak_signal):\n\n w_model = train_weak_signals(data, weak_signal_data, num_weak_signal)\n\n training_data = data['training_data'][0].T\n training_labels = data['training_data'][1]\n val_data, val_labels = data['validation_data']\n val_data = val_data.T\n test_data = data['test_data'][0].T\n test_labels = data['test_data'][1]\n\n num_features, num_data_points = training_data.shape\n\n weak_signal_ub = w_model['error_bounds']\n weak_signal_probabilities = w_model['probabilities']\n weak_test_accuracy = w_model['test_accuracy']\n\n weights = np.zeros(num_features)\n\n print(\"Running tests...\")\n\n optimized_weights, ineq_constraint = train_all(val_data, weights, weak_signal_probabilities, weak_signal_ub, max_iter=5000)\n\n # calculate test probabilities\n test_probabilities = probability(test_data, optimized_weights)\n # calculate test accuracy\n test_accuracy = getModelAccuracy(test_probabilities, test_labels)\n\n print(\"\")\n print(\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\")\n print(\"Experiment %d\"%num_weak_signal)\n print(\"We trained %d learnable classifiers with %d weak signals\" %(1, num_weak_signal))\n print(\"The accuracy of the model on the test data is\", test_accuracy)\n print(\"The accuracy of weak signal(s) on the test data is\", weak_test_accuracy)\n print(\"\")\n\n # calculate ge criteria\n print(\"Running tests on ge criteria...\")\n model = ge_criterion_train(val_data.T, val_labels, weak_signal_probabilities, num_weak_signal)\n ge_test_accuracy = accuracy_score(test_labels, np.round(probability(test_data, model)))\n print(\"The accuracy of ge criteria on test data is\", ge_test_accuracy)\n print(\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\")\n\n # calculate baseline\n print(\"Running tests on the baselines...\")\n baselines = runBaselineTests(val_data, weak_signal_probabilities)\n b_test_accuracy = getWeakSignalAccuracy(test_data, test_labels, baselines)\n print(\"The accuracy of the baseline models on test data is\", b_test_accuracy)\n print(\"\")\n\n output = {}\n output['ALL'] = test_accuracy\n output['WS'] = w_model['test_accuracy'][-1]\n output['GE'] = ge_test_accuracy\n output['AVG'] = b_test_accuracy[-1]\n\n return output","def get_E(self):\r\n return self.E","def E(self):\n\n print(\"\", file=self.logfile)\n print(\"Updating R\", file=self.logfile)\n\n\n TAE = toeplitz(self.A*self.e2[:self.P+1], np.zeros(self.P+1))\n TA = toeplitz(self.A, np.zeros(self.P+1))\n M = np.dot(TAE.transpose(), TA)\n res = toeplitz(np.concatenate([M[:,0], np.zeros((self.L_h-self.P-1))]),\n np.concatenate([M[0,:], np.zeros((self.L_h-self.P-1))]))\n res[-self.P:, -self.P:] = M[1:,1:]\n res = res*np.array([self.e2]).transpose()\n self.R = self.la*self.sigma2*np.linalg.inv(self.la*np.eye(self.L_h) + self.sigma2*res)\n\n\n\n print(\"\", file=self.logfile)\n print(\"Updating mu\", file=self.logfile)\n self.mu = np.dot(self.R, self.h)/self.sigma2\n\n\n # Propagate\n self._propagate_mu()\n self._propagate_R()","def calcEVals(self):\n self.eVals,self.eVecs = np.linalg.eigh(self.rhoOp)","def test_calc_baseline_error_to_observed_error(self):\r\n exp_ratio = calc_baseline_error_to_observed_error(\r\n self.baseline_error_input,\r\n self.obs_error_input)\r\n self.assertEqual(self.ratio_result, exp_ratio)","def errorEMat(E1, E2):\n E1_normalized = E1 / E1[2][2];\n E2_normalized = E2 / E2[2][2];\n return torch.norm(E1_normalized - E2_normalized)","def energy_func(self):\n i = self.inl[0].to_flow()\n o = self.outl[0].to_flow()\n\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\n\n return (i[0] * (o[2] - i[2]) -\n self.A.val * (\n self.E.val * self.eta_opt.val -\n (T_m - self.Tamb.val_SI) * self.lkf_lin.val -\n self.lkf_quad.val * (T_m - self.Tamb.val_SI) ** 2))","def calcError(self, inherited_error):\r\n\t\tif inherited_error == None:\t\t# output neurons\r\n\t\t\tself.error = (self.target - self.value) * self.activate_der()\r\n\t\telse:\r\n\t\t\tself.error = inherited_error * self.activate_der()","def evaluate_acc_eer(net, data_loader):\n correct = 0\n total = 0\n net.reset()\n target_scores = []\n non_target_scores = []\n for data in tqdm(data_loader):\n sample_input, output = data[0], data[1]\n sample_input = whiten(sample_input)\n mask, score = gate_activation(net, sample_input)\n selected_score = score[mask]\n if selected_score.size == 0:\n xo = 0.5\n else:\n xo = np.sum(selected_score) / selected_score.size\n total += 1\n correct += ((xo > 0.5) == output)\n if output == 1:\n target_scores.append(xo)\n else:\n non_target_scores.append(xo)\n\n target_scores = np.array(target_scores)\n non_target_scores = np.array(non_target_scores)\n\n pmiss, pfa = rocch(target_scores, non_target_scores)\n eer = rocch2eer(pmiss, pfa)\n\n return float(correct) / total, eer","def energy_func(self):\n i = self.inl[0].to_flow()\n o = self.outl[0].to_flow()\n\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\n\n iam = (\n 1 - self.iam_1.val * abs(self.aoi.val) -\n self.iam_2.val * self.aoi.val ** 2)\n\n return (i[0] * (o[2] - i[2]) -\n self.A.val * (\n self.E.val * self.eta_opt.val * self.doc.val ** 1.5 * iam -\n (T_m - self.Tamb.val_SI) * self.c_1.val -\n self.c_2.val * (T_m - self.Tamb.val_SI) ** 2))","def calc_error(y_real, y_pred):\n if len(y_real) > 0:\n curr_err = rmse(y_pred, y_real)\n else:\n curr_err = np.nan\n return curr_err","def eccentricity(self):\n return sqrt(self.f * 2 - self.f ** 2)","def evaluation_error(y_real, y_pred, max_rating, min_rating):\n mae = mean_absolute_error(y_real, y_pred)\n nmae = normalized_mean_absolute_error(y_real, y_pred,\n max_rating, min_rating)\n rmse = root_mean_square_error(y_real, y_pred)\n\n return mae, nmae, rmse","def test_check_conformer_energy(self):\n v_list = [-272.2779012225, -272.2774933703, -272.2768397635, -272.2778432059, -272.278645477, -272.2789602654,\n -272.2788749196, -272.278496709, -272.2779350675, -272.2777008843, -272.2777167286, -272.2780937643,\n -272.2784838846, -272.2788050464, -272.2787865352, -272.2785091607, -272.2779977452, -272.2777957743,\n -272.2779134906, -272.2781827547, -272.278443339, -272.2788244214, -272.2787748749]\n v_list = np.array(v_list, np.float64)\n v_diff = (v_list[0] - np.min(v_list)) * constants.E_h * constants.Na / 1000\n self.assertAlmostEqual(v_diff / 2.7805169838282797, 1, 5)","def get_R_e_test(E, M, g_e, T_e, R_e, epsilon):\n R_e_test = np.zeros((M,M))\n for i in range(M):\n for j in range(M):\n if i != j:\n R_e_test[i,j] = g_e**2*(E[i] - E[j])/(np.exp((E[i] \n - E[j])/T_e)-1)\n else:\n R_e_test[i,j] = g_e**2 * T_e\n return np.abs(R_e_test - R_e) < epsilon","def keV(E):\n if np.min(E) >= 100:\n return E / 1000\n else:\n return E","def get_error(self, params):\n return self.endog - self.predict(params)","def eci(self):\n return self.__eci","def error_rate(self):\n\n\t\treturn theano.tensor.mean(theano.tensor.neq(\n\t\t\tself.get_symbolic_predicted_labels(),\n\t\t\tself.symbolic_output))","def error_calculation_test(self):\n dataOrg = [[1,1], [2,2], [3,3], [4,4], [5,5], [6,6], [7,8], [7.3, 5], [8, 0], [9,10]]\n dataCalc = [[1,3], [2,5], [3,0], [4,3], [5,5], [6.1,6], [7,3], [7.3, 5], [8, 0], [9,9]]\n # abs difference: 2 3 3 1 0 NA 5 0 NA 1\n # local errors: 200 150 200 50 0 NA 125 0 NA 20\n # sum: 745\n\n tsOrg = TimeSeries.from_twodim_list(dataOrg)\n tsCalc = TimeSeries.from_twodim_list(dataCalc)\n\n wmape = WeightedMeanAbsolutePercentageError()\n wmape.initialize(tsOrg, tsCalc)\n assert str(wmape.get_error())[:6] == \"93.125\"","def estimate_accuracy(yEv, yEv_calc, disp = False):\n\n\tr_sqr = metrics.r2_score( yEv, yEv_calc)\n\tRMSE = np.sqrt( metrics.mean_squared_error( yEv, yEv_calc))\n\tMAE = metrics.mean_absolute_error( yEv, yEv_calc)\n\tDAE = metrics.median_absolute_error( yEv, yEv_calc)\n\n\tif disp:\n\t\tprint(\"r^2={0:.2e}, RMSE={1:.2e}, MAE={2:.2e}, DAE={3:.2e}\".format( r_sqr, RMSE, MAE, DAE))\n\n\treturn r_sqr, RMSE, MAE, DAE","def erf(t):\n P = 0.3275911\n A = [0.254829592, -0.284496736, 1.421413741, -1.453152027, 1.061405429]\n T = 1.0 / (1 + P * t)\n Tn = T\n Poly = A[0] * Tn\n for i in range(1, 5):\n Tn = Tn * T\n Poly = Poly * A[i] * Tn\n return 1.0 - Poly * np.exp(-t * t)","def B_res_e(f_ece, harm = 1.):\n return me/eV2J*f_ece*np.pi*2./harm","def test_rr_se(results):\n truese = np.asarray([2.09826858, 30.60745128, 108.51947421, 0.95693751,\n 0.6564318])\n test_se = results.params_se()\n assert test_se == pytest.approx(truese)","def calc_error_dist(self):\n pass","def get_deltaE(self):\n return self.deltaE"],"string":"[\n \"def calculate_hr_ee(self):\\n\\n # HR - resting HR = net HR\\n net_hr = np.array([i - self.rest_hr if i is not None else None for i in self.df_epoch[\\\"HR\\\"]])\\n\\n # Sets values below 0% HRR (below resting HR) to 0\\n net_hr[net_hr <= 0] = 0\\n\\n # Equation from Brage et al., 2004. Active EE in kJ/kg/min\\n kj_kg_min = [.011 * (hr ** 2) + 5.82 * hr if hr is not None else None for hr in net_hr]\\n\\n # Converts kJ to kcal: relative EE (kcal/kg/min)\\n kcal_kg_min = [k / 4.184 if k is not None else None for k in kj_kg_min]\\n\\n # Converts relative EE to absolute EE (kcal/min)\\n kcal_min = [k * self.weight / 1000 if k is not None else None for k in kcal_kg_min]\\n\\n # kcals per epoch instead of per minute\\n kcal_epoch = [k * (15 / 60) for k in kcal_min]\\n\\n total_ee = sum([i for i in kcal_epoch if not np.isnan(i)])\\n print(\\\"-Total energy expenditure estimated from HR is {} kcal.\\\".format(int(total_ee)))\\n\\n self.df_epoch[\\\"HR_EE\\\"] = kcal_min\",\n \"def rae(self) -> float:\\n return float(np.sum(self._ae()) / (np.sum(np.abs(self.true - np.mean(self.true))) + EPS))\",\n \"def diff_of_errors(self):\\n self.e_of_e = self.azimuth_error - self.altitude_error\\n return self.e_of_e\",\n \"def e(self):\\n\\n ylow = self.e_min\\n yhigh = self._e\\n\\n xlow = 0\\n xhigh = self.anneal_max\\n\\n steep_mult = 8\\n\\n steepness = steep_mult / (xhigh - xlow)\\n offset = (xhigh + xlow) / 2\\n midpoint = yhigh - ylow\\n\\n x = np.clip(self.avg_score, 0, xhigh)\\n x = steepness * (x - offset)\\n e = ylow + midpoint / (1 + np.exp(x))\\n return e\",\n \"def compute_EER(self, FAR, FRR):\\r\\n print('Computing EER')\\r\\n distance = abs(FAR - FRR)\\r\\n min_distance = min(distance)\\r\\n idx = np.where(distance == min_distance)\\r\\n return np.mean((FAR[idx] + FRR[idx]) / 2)\",\n \"def test_epe_evaluate(self):\\n epe_metric = EPE()\\n epe_metric.process(self.data_batch, self.data_samples)\\n epe = epe_metric.evaluate(1)\\n self.assertAlmostEqual(epe['EPE'], 11.5355339)\",\n \"def calculate_energy_conservation_error(self):\\n assert self.data is not None\\n # calculate total energy at start and end of simulation\\n energy_start = self.measure_total_energy(self.t0)\\n energy_end = self.measure_total_energy(self.t1)\\n \\n # calculate accuracy\\n error = abs(1.0 - energy_start/energy_end)\\n \\n return error\",\n \"def _calc_Em(self):\\n return (self.parameters.E0 +\\n self.x * sqrt2 * self.parameters.sigma * self.mt)\",\n \"def ivrmse(self):\\n return (self.model_error_iv()**2).mean()**.5\",\n \"def e(self):\\n if self._e is None:\\n # self._e = self.distributions.uniform(0.3,0.33)\\n # return self._e\\n # max is set by q but also limited by users choice of e_max.\\n res_a = 29.9*((self.j[0]/self.k[0])**(2/3))\\n q = self.distributions.truncated_normal(self.q_c, self.q_w, res_a*(1-0.8), res_a*(1-0.001))\\n self._e = 1 - q/res_a\\n return self._e\",\n \"def erf(data):\\n return _make.erf(data)\",\n \"def _calculate_measurement_error(self): \\n \\n # Calculate Hartmann Spot\\n # FIXME what are factor_1, factor_2 ???\\n factor_1, factor_2 = 206265*5.89e-7, 206265*6.5e-7\\n term1, term2 = factor_1/self.actuator_spacing, factor_2/self.r0\\n hartmann_spot = np.max([term1, term2])\\n \\n # Calculate SNR \\n n_pix=4 # FIXME spreadsheet says not to change this idk why?\\n sample_time = 1/(10*self.controller_frequency)\\n brightness = (8.9e5)*10**((0-self.guide_star_mag)/2.5)\\n n_photons = brightness*sample_time*((100*self.actuator_spacing)**2)\\n snr = n_photons/np.sqrt(n_photons + n_pix*(self.sigma_readnoise)**2)\\n\\n # Calculate noise propagator \\n degrees_of_freedom = np.round((np.pi/4) * (self.telescope_diameter/self.actuator_spacing)**2)\\n factor_1, factor_2 = 0.0536, 0.0795 # FIXME WHAT THE HECK IS THIS\\n if self.aperture == 'circular':\\n factor_1, factor_2 = 0.0068, 0.0796\\n noise_propagator = np.sqrt(2*(factor_1 + factor_2*np.log(degrees_of_freedom)))\\n\\n # Calculate close loop averaging\\n controller_over_frame = 1/10\\n close_loop_averaging = np.sqrt(2*controller_over_frame)*np.arctan(1/(2*controller_over_frame))\\n sigma_measurement = noise_propagator * close_loop_averaging * (self.actuator_spacing*1e9) * (hartmann_spot/snr*4.84814e-6)\\n self.sigma_measurement = sigma_measurement # in nm\",\n \"def eccentricAnomaly(e, M):\\n E = M if e < 0.8 else math.pi\\n \\n F = E - e*math.sin(M) - M\\n for i in range(100):\\n E = E - F/(1.0-e*math.cos(E))\\n F = E - e*math.sin(E) - M\\n if math.fabs(F)<1e-16:\\n break\\n E = mod2pi(E)\\n return E\",\n \"def compute_RMSE(e):\\n \\\"\\\"\\\"Corresponds to sqrt(2*MSE)\\\"\\\"\\\"\\n \\n return np.sqrt(2*compute_MSE(e))\",\n \"def emissivity_profile(R):\\n E = R**(-3.0)*(1 - (R_in/R)**(1.0/2.0))\\n return E\",\n \"def get_E(self):\\r\\n return self.Real.E, self.Ideal.E\",\n \"def get_E(self):\\r\\n return self.Real.E, self.Ideal.E\",\n \"def calculate_error(self):\\n \\n delta = self.Y - self.T\\n error = delta.dot(delta) / self.N\\n error = format(error, '.5f')\\n \\n self.errors.append(error)\",\n \"def euler_error(Rd, Re):\\n\\n nd = Rd[:, 0]\\n sd = Rd[:, 1]\\n ad = Rd[:, 2]\\n\\n ne = Re[:, 0]\\n se = Re[:, 1]\\n ae = Re[:, 2]\\n\\n return 0.5 * (np.cross(ne, nd) + np.cross(se, sd) + np.cross(ae, ad)) # eqn 3.85\",\n \"def adjust_E(self, power):\\n if self.pwr_in_tot:\\n fac = power/self.pwr_in_tot\\n else:\\n fac = 1.0\\n fac = min(1.01, fac)\\n self.Ey = sqrt(fac)*self.Ey\",\n \"def test_exponential_answer(self):\\r\\n answer = 50\\r\\n correct_responses = [\\r\\n \\\"50\\\", \\\"50.0\\\", \\\"5e1\\\", \\\"5e+1\\\",\\r\\n \\\"50e0\\\", \\\"50.0e0\\\", \\\"500e-1\\\"\\r\\n ]\\r\\n incorrect_responses = [\\\"\\\", \\\"3.9\\\", \\\"4.1\\\", \\\"0\\\", \\\"5.01e1\\\"]\\r\\n\\r\\n for input_str in correct_responses:\\r\\n result = calc.evaluator({}, {}, input_str)\\r\\n fail_msg = \\\"Expected '{0}' to equal {1}\\\".format(\\r\\n input_str, answer\\r\\n )\\r\\n self.assertEqual(answer, result, msg=fail_msg)\\r\\n\\r\\n for input_str in incorrect_responses:\\r\\n result = calc.evaluator({}, {}, input_str)\\r\\n fail_msg = \\\"Expected '{0}' to not equal {1}\\\".format(\\r\\n input_str, answer\\r\\n )\\r\\n self.assertNotEqual(answer, result, msg=fail_msg)\",\n \"def energy(e: float) -> float:\\n\\n return (1/np.sqrt(2))*(gamma(-e/2+1/2)/(gamma(-e/2+3/4)))\",\n \"def mrae(self, benchmark: np.ndarray = None):\\n return float(np.mean(np.abs(self._relative_error(benchmark))))\",\n \"def calcEout(model_type): \\n b, v = calcStatistics(model_type)\\n return b + v\",\n \"def get_e(self):\\n return self.e_min + self.e_ * self.e_range\",\n \"def inrse(self) -> float:\\n return float(np.sqrt(np.sum(np.square(self._error())) / np.sum(np.square(self.true - np.mean(self.true)))))\",\n \"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])**2\\n # id-isolation\\n unc += (self._eleIdIsoWeight[(e1.pt(),e1.eta())][1]/self._eleIdIsoWeight[(e1.pt(),e1.eta())][0] + \\\\\\n self._eleIdIsoWeight[(e2.pt(),e2.eta())][1]/self._eleIdIsoWeight[(e2.pt(),e2.eta())][0])**2\\n # trigger (approximate)\\n unc += (abs(self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][1]+ \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][1]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][1]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]- \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][1])/ \\\\\\n (self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]))**2\\n unc += ((self._ele8TrgWeight[(e1.pt(),e1.eta())][1]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][1])/ \\\\\\n (self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]))**2\\n #outcome\\n return sqrt(unc)\",\n \"def calculate_wrist_ee(self):\\n\\n data = [i * (30 / 75) for i in self.df_epoch[\\\"LWrist\\\"]]\\n\\n # Modified equation from Powell et al. 2017. Removed resting component (constant = 1.15451)\\n mets = [.022261 * i for i in data]\\n\\n # Converts METs to relative VO2 (mL O2/kg/min)\\n r_vo2 = [3.5 * m for m in mets]\\n\\n # Converts relative VO2 to absolute VO2 (L O2/kg/min)\\n a_vo2 = [i * self.weight / 1000 for i in r_vo2]\\n\\n # Converts absolute VO2 to kcal/min (assumes 1 L O2 -> 4.825 kcal)\\n kcal_min = [a * 4.825 for a in a_vo2]\\n\\n # Calculates kcal/epoch\\n kcal_epoch = [k * (15 / 60) for k in kcal_min]\\n\\n total_ee = sum([i for i in kcal_epoch if not np.isnan(i)])\\n print(\\\"-Total energy expenditure estimated from Wrist is {} kcal.\\\".format(int(total_ee)))\\n\\n self.df_epoch[\\\"Wrist_EE\\\"] = kcal_min\",\n \"def E(self, dstrct):\\n rep_votes = dstrct.rep_votes + self.properties['sen_red']\\n dem_votes = dstrct.dem_votes + self.properties['sen_blue']\\n\\n thresh = threshold(rep_votes+dem_votes)\\n rep_wasted = wasted_votes(rep_votes, thresh)\\n dem_wasted = wasted_votes(dem_votes, thresh)\\n gap = (rep_wasted - dem_wasted)/(rep_votes + dem_votes)\\n score = 1-abs(gap)\\n\\n self.E_ = self.w_E * score\\n return self.E_\",\n \"def rmse(self):\\n return (self.model_error()**2).mean()**.5\",\n \"def E(self):\\n return self.generic_getter(get_energy, \\\"E\\\", \\\"convert_energy\\\")\",\n \"def get_error_rates():\\n return [ERR_RT * i for i in range(int((1 / ERR_RT) / 4))] # error up to 25%\",\n \"def ErrorCorrect(val,fEC):\\n return val * fEC\",\n \"def compute_MSE(e):\\n\\n return 1/2*np.mean(e**2)\",\n \"def get_R_e(E, M, g_e, T_e):\\n # transform energy-vector into matrices\\n mat_E_x, mat_E_y = np.meshgrid(E,E) \\n mat_diff = mat_E_y - mat_E_x # matrix representing: E_i - E_j\\n R_e = np.ones((M,M))*g_e**2 * T_e # matrix for transition rates\\n ind = np.abs(mat_diff) > 0 # indices of the non-divergent elements\\n # fill in just those elements without divergences 1/0\\n # the rest is set to the correct limit\\n R_e[ind] = g_e**2 * mat_diff[ind]/(np.exp(mat_diff[ind]/T_e)-1)\\n return R_e\",\n \"def calculate_exponent():\\n pass\",\n \"def mean_error(self) -> float:\\n self.ME = sum(np.array(self.sim_data[\\\"Human (mean)\\\"]) - np.array(self.sim_data[\\\"assigned_sim\\\"])) / len(self.sim_data)\\n return self.ME\",\n \"def calculate_mse(e):\\r\\n return 1/2*np.mean(e**2)\",\n \"def rrse(self) -> float:\\n return float(np.sqrt(self.rse()))\",\n \"def error(self, trainset: ([], [])):\\n # MSE = Σ | d – y |^2 / n\\n error_sum = 0.0\\n for index, example in enumerate(trainset):\\n # | d – y |^2\\n output = self.activate(example[0])\\n\\n target = example[1][0]\\n\\n error = target - output\\n error_sum += error ** 2\\n\\n # Σ |error_sum| / n\\n error_sum = error_sum / len(trainset)\\n return error_sum\",\n \"def energy(self):\\n e = 0\\n\\n restoration = RestorationModel(self.graph_damaged)\\n restoration.run(self.state)\\n restoration_graphs = restoration.get_restoration_graphs()\\n restoration_times = restoration.get_restoration_times()\\n restoration_costs = restoration.get_restoration_costs()\\n\\n damaged = []\\n damaged.append(get_delta(self.no_damage, self.initial_damage))\\n\\n sim_results = Parallel(n_jobs=4)(delayed(parallel_model)(\\n graph, self.od_graph, self.od_matrix) for graph in restoration_graphs[:-1])\\n for values in sim_results:\\n damaged.append(get_delta(self.no_damage, values))\\n\\n for idx, values in enumerate(damaged):\\n dt = restoration_times[idx] if idx == 0 else restoration_times[idx] - \\\\\\n restoration_times[idx-1]\\n e += sum(restoration_costs[idx]) + dt * (self.day_factor * values[2] * np.sum(self.mu*self.xi) +\\n values[3] * np.sum(self.mu * (self.nu * self.F_w + self.rho)) + values[4] * self.upsilon)\\n with open(self.fdir+'energy.csv', 'a') as f:\\n f.write('\\\\n'+str(e))\\n\\n return e\",\n \"def Eee(h_in, h_out, neutron_spectrum):\\n h_out.Scale(0.098)\\n neutron_spectrum.Add(h_in, 1)\\n neutron_spectrum.Add(h_out, -1)\\n neutron_spectrum.Fit('gaus')\\n #neutron_spectrum.Draw()\\n #input()\\n results_fit = neutron_spectrum.GetFunction('gaus')\\n mean_energy = results_fit.GetParameter(1)\\n spread_energy = results_fit.GetParError(1)\\n return mean_energy, spread_energy\",\n \"def _Ep(self):\\n return np.logspace(np.log10(self.Epmin.to('GeV').value),np.log10(self.Epmax.to('GeV').value),\\n self.nEpd * (np.log10(self.Epmax/self.Epmin)))\",\n \"def eccentricity(self):\\n return self.b / self.a\",\n \"def delta_energy(atom,layer1,layer2):\\n global r,c,h\\n return float('%.2E' % Decimal(str(r*((atom**2/layer1**2)-(atom**2/layer2**2)))))\",\n \"def calculateErrorRate(numCorrect, numWrong):\\n return np.round((numWrong)/(numCorrect+numWrong),3)\",\n \"def mbe(self) -> float:\\n return float(np.mean(self._error(self.true, self.predicted)))\",\n \"def erf(x):\\n return 0.0\",\n \"def E_fermi(n_e):\\n return n_e / nu0 # in K\",\n \"def Hydrogen_Rate(E):\\n\\treturn (4.0/E)*np.exp(-(2.0/3.0)/E)\",\n \"def calculate_improved_euler(self, delta_time=0.02, iterations=100):\\n predator_history = []\\n prey_history = []\\n print self.predators\\n print self.prey\\n predator_history.append(self.predators)\\n prey_history.append(self.prey)\\n print predator_history\\n print prey_history\\n harvesting_effort_history = []\\n print self.prey\\n for i in range(iterations):\\n xk_1 = self.prey_change(self.prey, self.predators) * delta_time\\n yk_1 = self.predator_change(self.prey, self.predators) * delta_time\\n xk_2 = self.prey_change(self.prey + xk_1, self.predators + yk_1) * delta_time\\n yk_2 = self.predator_change(self.prey + xk_1, self.predators + yk_1) * delta_time\\n\\n\\n self.prey = self.prey_change(self.prey, self.predators)\\n self.predators = self.predator_change(self.prey, self.predators)\\n\\n predator_history.append(self.predators)\\n prey_history.append(self.prey)\\n\\n return {'predator': predator_history, 'prey': prey_history}\",\n \"def calc_ema(self):\\n emaFactor = self.settings['emaFactor']\\n stepFactor = emaFactor ** self.vars['dt']\\n if self.vars['step'] == 0:\\n ema = float('NaN')\\n elif self.vars['step'] == 1:\\n ema = self.vars['speed_trace'][1]\\n else:\\n ema = stepFactor * self.vars['ema_trace'][self.vars['step'] - 1] + (\\n 1 - stepFactor)*self.vars['speed_trace'][self.vars['step']]\\n return ema\",\n \"def energy(self):\\n nocc, gmo, e = self.nocc, self.gmo, self.e\\n\\n Ec = 0.0\\n for i in range(nocc):\\n for j in range(nocc):\\n for a in range(nocc, len(e)):\\n for b in range(nocc, len(e)):\\n Ec += (1/4.0) * gmo[i, j, a, b]**2 / (e[i]+e[j]-e[a]-e[b])\\n\\n self.Ec = Ec\\n self.E_mp2 = Ec + self.E_scf\\n\\n print('@MP2 correlation energy: {:15.10f}\\\\n'.format(self.Ec))\\n print('@Total MP2 energy: {:15.10f}\\\\n'.format(self.E_mp2))\\n\\n return self.E_mp2\",\n \"def test_mcintosh_e(self):\\n c = array([1,2,3,1])\\n num = sqrt(15)\\n den = sqrt(19)\\n exp = num/den\\n self.assertEqual(mcintosh_e(c), exp)\",\n \"def energy_atom(atom,layer):\\n global r,c,h\\n backval= r*((atom**2/layer**2))\\n return float('%.2E' % Decimal(str(backval)))\",\n \"def _emiss_ep(self,Eph):\\n if self.weight_ep == 0.0:\\n return np.zeros_like(Eph)\\n\\n gam = np.vstack(self._gam)\\n eps = (Eph / mec2).decompose().value\\n # compute integral with electron distribution\\n emiss = c.cgs * trapz_loglog(np.vstack(self._nelec) * self._sigma_1(gam,eps),\\n self._gam, axis=0).to(u.cm**2 / Eph.unit)\\n return emiss\",\n \"def eccentricity(self):\\n new_data = self._data[['pl_pnum', 'pl_orbper', 'pl_orbsmax',\\n 'pl_masse', 'pl_orbeccen',\\n 'pl_radj', 'pl_dens', 'st_teff',\\n 'st_mass', 'st_rad']]\\n new_data = new_data.dropna()\\n\\n features = new_data[['pl_pnum', 'pl_orbper', 'pl_orbsmax',\\n 'pl_masse',\\n 'pl_radj', 'pl_dens', 'st_teff',\\n 'st_mass', 'st_rad']]\\n labels = new_data['pl_orbeccen']\\n\\n features_train, features_test, labels_train, labels_test = \\\\\\n train_test_split(features, labels, test_size=0.2)\\n\\n # Create an untrained model\\n model = DecisionTreeRegressor()\\n\\n # Train it on the **training set**\\n model.fit(features_train, labels_train)\\n\\n # Compute test accuracy\\n test_predictions = model.predict(features_test)\\n test_acc = mean_absolute_error(labels_test, test_predictions)\\n test_acc_r2 = r2_score(labels_test, test_predictions)\\n\\n # Plot ML vs Actual\\n fig, [ax1, ax2] = plt.subplots(2, figsize=(15, 12))\\n\\n sns.distplot(test_predictions, kde=False, ax=ax1)\\n sns.distplot(labels_test, kde=False, ax=ax2)\\n\\n ax1.set_title('Distribution of Predicted Eccentricities of Orbits')\\n ax1.set_xlabel('Eccentricity of Orbit')\\n ax1.set_ylabel('Number of Planets')\\n\\n ax2.set_title('Distribution of Actual Eccentricities of Orbits')\\n ax2.set_xlabel('Eccentricity of Orbit')\\n ax2.set_ylabel('Number of Planets')\\n\\n plt.savefig('figures/ML_Eccentricity.png', bbox_inches='tight')\\n\\n return (test_acc, test_acc_r2)\",\n \"def error_compute(self):\\n self.tt_error = np.linalg.norm(self.rel_error)\\n if self.global_rank==0:print('Overall error is::',self.tt_error)\\n return {'NMF': self.rel_error, 'tt': self.tt_error}\",\n \"def get_E(self):\\n return self.E\",\n \"def energy(self):\\n nocc, ntot, gmo, e = self.nocc, self.ntot, self.gmo, self.e\\n\\n Ec = 0.0\\n for i in range(nocc):\\n for j in range(nocc):\\n for a in range(nocc, ntot):\\n for b in range(nocc, ntot):\\n Ec += gmo[i, a, j, b]*(2*gmo[i, a, j, b] - gmo[i, b, j, a])/\\\\\\n (e[i] + e[j] - e[a] - e[b])\\n\\n self.Ec = Ec\\n self.E_mp2 = Ec + self.E_scf\\n\\n print('@MP2 correlation energy: {:15.10f}\\\\n'.format(self.Ec))\\n print('@Total MP2 energy: {:15.10f}\\\\n'.format(self.E_mp2))\\n\\n return self.E_mp2\",\n \"def adjacent_error(self, field, exclude=False):\\n\\n self.log.info('Running the adjacent error computation for quantity %s', field)\\n # If we need to exclude calculate the indices\\n if exclude:\\n start, end = self.get_slice(self.sims[0])\\n excluded = '_excluded'\\n else:\\n start = 0\\n end = None\\n excluded = ''\\n base = self.sims[0].conf['General']['results_dir']\\n errpath = os.path.join(base, 'adjacenterror_%s%s.dat' % (field, excluded))\\n with open(errpath, 'w') as errfile:\\n self.log.info('Computing adjacent error for sweep %s', base)\\n # For all other sims in the groups, compare to best estimate\\n # and write to error file\\n for i in range(1, self.num_sims):\\n # Set reference sim\\n ref_sim = self.sims[i]\\n # Get the comparison vector\\n vecs1, normvec = self.get_comp_vec(ref_sim, field, start, end)\\n sim2 = self.sims[i - 1]\\n vecs2, normvec2 = self.get_comp_vec(sim2, field, start, end)\\n self.log.info(\\\"Computing adjacent error between numbasis %i and numbasis %i\\\",\\n ref_sim.conf['Simulation'][ 'params']['numbasis'],\\n sim2.conf['Simulation']['params']['numbasis'])\\n # Get the array containing the magnitude of the difference vector at each point\\n # in space\\n mag_diff_vec = self.diff_sq(vecs1, vecs2)\\n # Check for equal lengths between norm array and diff mag\\n # array\\n if len(mag_diff_vec) != len(normvec):\\n self.log.error(\\\"The normalization vector has an incorrect number of elements!!!\\\")\\n raise ValueError\\n # Error as a percentage should be thkkk square root of the ratio of sum of mag diff vec\\n # squared to mag efield squared\\n error = np.sqrt(np.sum(mag_diff_vec) / np.sum(normvec))\\n # self.log.info(str(error))\\n errfile.write('%i,%f\\\\n' % (sim2.conf['Simulation']['params']['numbasis'], error))\\n sim2.clear_data()\\n ref_sim.clear_data()\",\n \"def _emiss_ee(self,Eph):\\n if self.weight_ee == 0.0:\\n return np.zeros_like(Eph)\\n\\n gam = np.vstack(self._gam)\\n # compute integral with electron distribution\\n emiss = c.cgs * trapz_loglog(np.vstack(self._nelec) * self._sigma_ee(gam,Eph),\\n self._gam, axis=0)\\n return emiss\",\n \"def computeEnergy(self):\\n\\t\\tGmo = self.Gmo\\n\\t\\te = self.e\\n\\t\\tself.Ec = 0.0\\n\\n\\t\\tfor i in range( self.nocc ):\\n\\t\\t\\tfor j in range( self.nocc ):\\n\\t\\t\\t\\tfor a in range( self.nocc,self.norb ):\\n\\t\\t\\t\\t\\tfor b in range( self.nocc,self.norb ):\\n\\t\\t\\t\\t\\t\\tself.Ec += 0.25*(Gmo[i,j,a,b]*Gmo[a,b,i,j])/(e[i]+e[j]-e[a]-e[b])\\n\\n\\t\\treturn self.E0 + self.Ec\",\n \"def error_rate(dataset, estimates):\\n\\tincorrect = 0.0\\n\\tcount = 0.0\\n\\n\\tfor idx in range(len(estimates)):\\n\\t\\testimate = estimates[idx]\\n\\t\\t_, actual = dataset[idx]\\n\\t\\tfor e, a in zip(estimate, actual):\\n\\t\\t\\tcount += 1.0\\n\\t\\t\\tif e != a:\\n\\t\\t\\t\\tincorrect += 1.0\\n\\t\\n\\treturn incorrect / count\",\n \"def mbrae(self, benchmark: np.ndarray = None) -> float:\\n return float(np.mean(self._bounded_relative_error(benchmark)))\",\n \"def Er( z, r, epsilon, k0, w0, wp, t) :\\n Er_array = \\\\\\n epsilon * m_e*c**2/e * 2*r/w0**2 * \\\\\\n np.exp( -r**2/w0**2 ) * np.sin( k0*z ) * np.sin( wp*t )\\n return( Er_array )\",\n \"def MSE_one_error(real,estimate):\\n error = mean_squared_error(real.T, estimate.T)\\n return error\",\n \"def Eee2(neutron_spectrum):\\n neutron_spectrum.Fit('gaus')\\n results_fit = neutron_spectrum.GetFunction('gaus')\\n mean_energy = results_fit.GetParameter(1)\\n spread_energy = results_fit.GetParError(1)\\n return mean_energy, spread_energy\",\n \"def pair_energy(self,e, s, r):\\n return 4.0*e*((s/r)**12-(s/r)**6)\",\n \"def get_error_estimates(self, Y, M1, M2=None):\\n # First K0 and K1\\n Mminus = M1\\n if M2 is None:\\n Mplus = M1\\n else:\\n Mplus = M2\\n if self.Cp0 != 0 and self.Cp1 != 0 and self.Cm != 0:\\n Cp0 = self.Cp0\\n Cp1 = self.Cp1\\n Cm = self.Cm\\n else:\\n PP = self.principal_part()\\n Cmax = max(PP.values())\\n Kmax = 0\\n for t in PP.keys():\\n if isinstance(t, tuple):\\n (c, l) = t\\n elif isinstance(t, (int, Integer)):\\n (c, l) = rn_from_D(self._space.multiplier(), t)\\n else:\\n raise ValueError(\\\"Incorrect principal part: t={0}\\\".format(t))\\n if c in self._space.multiplier().D():\\n tmp = l + self._space.multiplier().Qv[self._space.index_set().index(c)]\\n elif c in range(len(self._space.multiplier().Qv)):\\n tmp = l + self._space.multiplier().Qv[c]\\n else:\\n raise ValueError(\\\"Incorrect principal part: c,l={0},{1}\\\".format(c, l))\\n if(abs(tmp) > Kmax):\\n Kmax = abs(tmp)\\n [Cp0, Cp1] = self._space.get_Cp(Cmax)\\n Cm = self._space.get_Cm(Kmax, Cmax)\\n self.Cp0 = Cp0\\n self.Cp1 = Cp1\\n self.Cm = Cm\\n\\n fak = len(self._space.index_set())\\n # print \\\"Cp0,Cp1,Cm=\\\",Cp0,Cp1,Cm\\n # print \\\"fak=\\\",fak\\n\\n er1 = fak * self._space.err_est_vv_hwmf_neg(Y, Mminus, Cm)\\n er2 = fak * self._space.err_est_vv_hwmf_pos(Y, Mplus, Cp0, Cp1)\\n return [er1, er2]\",\n \"def energy(self, r):\\n sigma = self.params['sigma']\\n epsilon = self.params['epsilon']\\n s = sigma / r\\n s6 = s**6; s12 = s6 * s6\\n pot = 4.0 * epsilon * (s12 - s6)\\n return pot\",\n \"def gmrae(self, benchmark: np.ndarray = None) -> float:\\n return _geometric_mean(np.abs(self._relative_error(benchmark)))\",\n \"def E(self):\\n return self._E\",\n \"def E(self):\\n return self._E\",\n \"def dependent_error_exp(data, weak_signal_data, num_weak_signal):\\n\\n w_model = train_weak_signals(data, weak_signal_data, num_weak_signal)\\n\\n training_data = data['training_data'][0].T\\n training_labels = data['training_data'][1]\\n val_data, val_labels = data['validation_data']\\n val_data = val_data.T\\n test_data = data['test_data'][0].T\\n test_labels = data['test_data'][1]\\n\\n num_features, num_data_points = training_data.shape\\n\\n weak_signal_ub = w_model['error_bounds']\\n weak_signal_probabilities = w_model['probabilities']\\n weak_test_accuracy = w_model['test_accuracy']\\n\\n weights = np.zeros(num_features)\\n\\n print(\\\"Running tests...\\\")\\n\\n optimized_weights, ineq_constraint = train_all(val_data, weights, weak_signal_probabilities, weak_signal_ub, max_iter=5000)\\n\\n # calculate test probabilities\\n test_probabilities = probability(test_data, optimized_weights)\\n # calculate test accuracy\\n test_accuracy = getModelAccuracy(test_probabilities, test_labels)\\n\\n print(\\\"\\\")\\n print(\\\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n print(\\\"Experiment %d\\\"%num_weak_signal)\\n print(\\\"We trained %d learnable classifiers with %d weak signals\\\" %(1, num_weak_signal))\\n print(\\\"The accuracy of the model on the test data is\\\", test_accuracy)\\n print(\\\"The accuracy of weak signal(s) on the test data is\\\", weak_test_accuracy)\\n print(\\\"\\\")\\n\\n # calculate ge criteria\\n print(\\\"Running tests on ge criteria...\\\")\\n model = ge_criterion_train(val_data.T, val_labels, weak_signal_probabilities, num_weak_signal)\\n ge_test_accuracy = accuracy_score(test_labels, np.round(probability(test_data, model)))\\n print(\\\"The accuracy of ge criteria on test data is\\\", ge_test_accuracy)\\n print(\\\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n\\n # calculate baseline\\n print(\\\"Running tests on the baselines...\\\")\\n baselines = runBaselineTests(val_data, weak_signal_probabilities)\\n b_test_accuracy = getWeakSignalAccuracy(test_data, test_labels, baselines)\\n print(\\\"The accuracy of the baseline models on test data is\\\", b_test_accuracy)\\n print(\\\"\\\")\\n\\n output = {}\\n output['ALL'] = test_accuracy\\n output['WS'] = w_model['test_accuracy'][-1]\\n output['GE'] = ge_test_accuracy\\n output['AVG'] = b_test_accuracy[-1]\\n\\n return output\",\n \"def get_E(self):\\r\\n return self.E\",\n \"def E(self):\\n\\n print(\\\"\\\", file=self.logfile)\\n print(\\\"Updating R\\\", file=self.logfile)\\n\\n\\n TAE = toeplitz(self.A*self.e2[:self.P+1], np.zeros(self.P+1))\\n TA = toeplitz(self.A, np.zeros(self.P+1))\\n M = np.dot(TAE.transpose(), TA)\\n res = toeplitz(np.concatenate([M[:,0], np.zeros((self.L_h-self.P-1))]),\\n np.concatenate([M[0,:], np.zeros((self.L_h-self.P-1))]))\\n res[-self.P:, -self.P:] = M[1:,1:]\\n res = res*np.array([self.e2]).transpose()\\n self.R = self.la*self.sigma2*np.linalg.inv(self.la*np.eye(self.L_h) + self.sigma2*res)\\n\\n\\n\\n print(\\\"\\\", file=self.logfile)\\n print(\\\"Updating mu\\\", file=self.logfile)\\n self.mu = np.dot(self.R, self.h)/self.sigma2\\n\\n\\n # Propagate\\n self._propagate_mu()\\n self._propagate_R()\",\n \"def calcEVals(self):\\n self.eVals,self.eVecs = np.linalg.eigh(self.rhoOp)\",\n \"def test_calc_baseline_error_to_observed_error(self):\\r\\n exp_ratio = calc_baseline_error_to_observed_error(\\r\\n self.baseline_error_input,\\r\\n self.obs_error_input)\\r\\n self.assertEqual(self.ratio_result, exp_ratio)\",\n \"def errorEMat(E1, E2):\\n E1_normalized = E1 / E1[2][2];\\n E2_normalized = E2 / E2[2][2];\\n return torch.norm(E1_normalized - E2_normalized)\",\n \"def energy_func(self):\\n i = self.inl[0].to_flow()\\n o = self.outl[0].to_flow()\\n\\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\\n\\n return (i[0] * (o[2] - i[2]) -\\n self.A.val * (\\n self.E.val * self.eta_opt.val -\\n (T_m - self.Tamb.val_SI) * self.lkf_lin.val -\\n self.lkf_quad.val * (T_m - self.Tamb.val_SI) ** 2))\",\n \"def calcError(self, inherited_error):\\r\\n\\t\\tif inherited_error == None:\\t\\t# output neurons\\r\\n\\t\\t\\tself.error = (self.target - self.value) * self.activate_der()\\r\\n\\t\\telse:\\r\\n\\t\\t\\tself.error = inherited_error * self.activate_der()\",\n \"def evaluate_acc_eer(net, data_loader):\\n correct = 0\\n total = 0\\n net.reset()\\n target_scores = []\\n non_target_scores = []\\n for data in tqdm(data_loader):\\n sample_input, output = data[0], data[1]\\n sample_input = whiten(sample_input)\\n mask, score = gate_activation(net, sample_input)\\n selected_score = score[mask]\\n if selected_score.size == 0:\\n xo = 0.5\\n else:\\n xo = np.sum(selected_score) / selected_score.size\\n total += 1\\n correct += ((xo > 0.5) == output)\\n if output == 1:\\n target_scores.append(xo)\\n else:\\n non_target_scores.append(xo)\\n\\n target_scores = np.array(target_scores)\\n non_target_scores = np.array(non_target_scores)\\n\\n pmiss, pfa = rocch(target_scores, non_target_scores)\\n eer = rocch2eer(pmiss, pfa)\\n\\n return float(correct) / total, eer\",\n \"def energy_func(self):\\n i = self.inl[0].to_flow()\\n o = self.outl[0].to_flow()\\n\\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\\n\\n iam = (\\n 1 - self.iam_1.val * abs(self.aoi.val) -\\n self.iam_2.val * self.aoi.val ** 2)\\n\\n return (i[0] * (o[2] - i[2]) -\\n self.A.val * (\\n self.E.val * self.eta_opt.val * self.doc.val ** 1.5 * iam -\\n (T_m - self.Tamb.val_SI) * self.c_1.val -\\n self.c_2.val * (T_m - self.Tamb.val_SI) ** 2))\",\n \"def calc_error(y_real, y_pred):\\n if len(y_real) > 0:\\n curr_err = rmse(y_pred, y_real)\\n else:\\n curr_err = np.nan\\n return curr_err\",\n \"def eccentricity(self):\\n return sqrt(self.f * 2 - self.f ** 2)\",\n \"def evaluation_error(y_real, y_pred, max_rating, min_rating):\\n mae = mean_absolute_error(y_real, y_pred)\\n nmae = normalized_mean_absolute_error(y_real, y_pred,\\n max_rating, min_rating)\\n rmse = root_mean_square_error(y_real, y_pred)\\n\\n return mae, nmae, rmse\",\n \"def test_check_conformer_energy(self):\\n v_list = [-272.2779012225, -272.2774933703, -272.2768397635, -272.2778432059, -272.278645477, -272.2789602654,\\n -272.2788749196, -272.278496709, -272.2779350675, -272.2777008843, -272.2777167286, -272.2780937643,\\n -272.2784838846, -272.2788050464, -272.2787865352, -272.2785091607, -272.2779977452, -272.2777957743,\\n -272.2779134906, -272.2781827547, -272.278443339, -272.2788244214, -272.2787748749]\\n v_list = np.array(v_list, np.float64)\\n v_diff = (v_list[0] - np.min(v_list)) * constants.E_h * constants.Na / 1000\\n self.assertAlmostEqual(v_diff / 2.7805169838282797, 1, 5)\",\n \"def get_R_e_test(E, M, g_e, T_e, R_e, epsilon):\\n R_e_test = np.zeros((M,M))\\n for i in range(M):\\n for j in range(M):\\n if i != j:\\n R_e_test[i,j] = g_e**2*(E[i] - E[j])/(np.exp((E[i] \\n - E[j])/T_e)-1)\\n else:\\n R_e_test[i,j] = g_e**2 * T_e\\n return np.abs(R_e_test - R_e) < epsilon\",\n \"def keV(E):\\n if np.min(E) >= 100:\\n return E / 1000\\n else:\\n return E\",\n \"def get_error(self, params):\\n return self.endog - self.predict(params)\",\n \"def eci(self):\\n return self.__eci\",\n \"def error_rate(self):\\n\\n\\t\\treturn theano.tensor.mean(theano.tensor.neq(\\n\\t\\t\\tself.get_symbolic_predicted_labels(),\\n\\t\\t\\tself.symbolic_output))\",\n \"def error_calculation_test(self):\\n dataOrg = [[1,1], [2,2], [3,3], [4,4], [5,5], [6,6], [7,8], [7.3, 5], [8, 0], [9,10]]\\n dataCalc = [[1,3], [2,5], [3,0], [4,3], [5,5], [6.1,6], [7,3], [7.3, 5], [8, 0], [9,9]]\\n # abs difference: 2 3 3 1 0 NA 5 0 NA 1\\n # local errors: 200 150 200 50 0 NA 125 0 NA 20\\n # sum: 745\\n\\n tsOrg = TimeSeries.from_twodim_list(dataOrg)\\n tsCalc = TimeSeries.from_twodim_list(dataCalc)\\n\\n wmape = WeightedMeanAbsolutePercentageError()\\n wmape.initialize(tsOrg, tsCalc)\\n assert str(wmape.get_error())[:6] == \\\"93.125\\\"\",\n \"def estimate_accuracy(yEv, yEv_calc, disp = False):\\n\\n\\tr_sqr = metrics.r2_score( yEv, yEv_calc)\\n\\tRMSE = np.sqrt( metrics.mean_squared_error( yEv, yEv_calc))\\n\\tMAE = metrics.mean_absolute_error( yEv, yEv_calc)\\n\\tDAE = metrics.median_absolute_error( yEv, yEv_calc)\\n\\n\\tif disp:\\n\\t\\tprint(\\\"r^2={0:.2e}, RMSE={1:.2e}, MAE={2:.2e}, DAE={3:.2e}\\\".format( r_sqr, RMSE, MAE, DAE))\\n\\n\\treturn r_sqr, RMSE, MAE, DAE\",\n \"def erf(t):\\n P = 0.3275911\\n A = [0.254829592, -0.284496736, 1.421413741, -1.453152027, 1.061405429]\\n T = 1.0 / (1 + P * t)\\n Tn = T\\n Poly = A[0] * Tn\\n for i in range(1, 5):\\n Tn = Tn * T\\n Poly = Poly * A[i] * Tn\\n return 1.0 - Poly * np.exp(-t * t)\",\n \"def B_res_e(f_ece, harm = 1.):\\n return me/eV2J*f_ece*np.pi*2./harm\",\n \"def test_rr_se(results):\\n truese = np.asarray([2.09826858, 30.60745128, 108.51947421, 0.95693751,\\n 0.6564318])\\n test_se = results.params_se()\\n assert test_se == pytest.approx(truese)\",\n \"def calc_error_dist(self):\\n pass\",\n \"def get_deltaE(self):\\n return self.deltaE\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6688616","0.6576088","0.6453312","0.6436712","0.6268617","0.61915094","0.60727984","0.60624784","0.6055529","0.5957637","0.5948924","0.5935441","0.59333384","0.5899245","0.5894991","0.5884183","0.5884183","0.5883016","0.5870002","0.5867805","0.58296996","0.58256584","0.5806175","0.5805928","0.5803038","0.5796278","0.57854205","0.57710433","0.5754452","0.5753451","0.5747029","0.57426095","0.5742036","0.57251817","0.5707274","0.57006305","0.5694029","0.56927836","0.5681012","0.5664438","0.56557095","0.56531703","0.5649919","0.56457955","0.5641291","0.5625754","0.5624976","0.5624714","0.5620939","0.56174374","0.5616939","0.5610984","0.56067747","0.5603147","0.55961365","0.5594472","0.5593996","0.5593026","0.5592446","0.5584533","0.5579173","0.5578676","0.5578064","0.5572537","0.5561491","0.55601424","0.55594176","0.5553619","0.553965","0.55382764","0.5537258","0.552812","0.55208635","0.55208635","0.5518403","0.55179673","0.5515055","0.5510486","0.5509502","0.5506086","0.55057645","0.55053663","0.55025256","0.55017126","0.5500882","0.54932296","0.54819643","0.5481476","0.54799813","0.54792184","0.5472846","0.5469635","0.5468635","0.5462949","0.5461399","0.54491204","0.5448523","0.5445566","0.5444299","0.5437646"],"string":"[\n \"0.6688616\",\n \"0.6576088\",\n \"0.6453312\",\n \"0.6436712\",\n \"0.6268617\",\n \"0.61915094\",\n \"0.60727984\",\n \"0.60624784\",\n \"0.6055529\",\n \"0.5957637\",\n \"0.5948924\",\n \"0.5935441\",\n \"0.59333384\",\n \"0.5899245\",\n \"0.5894991\",\n \"0.5884183\",\n \"0.5884183\",\n \"0.5883016\",\n \"0.5870002\",\n \"0.5867805\",\n \"0.58296996\",\n \"0.58256584\",\n \"0.5806175\",\n \"0.5805928\",\n \"0.5803038\",\n \"0.5796278\",\n \"0.57854205\",\n \"0.57710433\",\n \"0.5754452\",\n \"0.5753451\",\n \"0.5747029\",\n \"0.57426095\",\n \"0.5742036\",\n \"0.57251817\",\n \"0.5707274\",\n \"0.57006305\",\n \"0.5694029\",\n \"0.56927836\",\n \"0.5681012\",\n \"0.5664438\",\n \"0.56557095\",\n \"0.56531703\",\n \"0.5649919\",\n \"0.56457955\",\n \"0.5641291\",\n \"0.5625754\",\n \"0.5624976\",\n \"0.5624714\",\n \"0.5620939\",\n \"0.56174374\",\n \"0.5616939\",\n \"0.5610984\",\n \"0.56067747\",\n \"0.5603147\",\n \"0.55961365\",\n \"0.5594472\",\n \"0.5593996\",\n \"0.5593026\",\n \"0.5592446\",\n \"0.5584533\",\n \"0.5579173\",\n \"0.5578676\",\n \"0.5578064\",\n \"0.5572537\",\n \"0.5561491\",\n \"0.55601424\",\n \"0.55594176\",\n \"0.5553619\",\n \"0.553965\",\n \"0.55382764\",\n \"0.5537258\",\n \"0.552812\",\n \"0.55208635\",\n \"0.55208635\",\n \"0.5518403\",\n \"0.55179673\",\n \"0.5515055\",\n \"0.5510486\",\n \"0.5509502\",\n \"0.5506086\",\n \"0.55057645\",\n \"0.55053663\",\n \"0.55025256\",\n \"0.55017126\",\n \"0.5500882\",\n \"0.54932296\",\n \"0.54819643\",\n \"0.5481476\",\n \"0.54799813\",\n \"0.54792184\",\n \"0.5472846\",\n \"0.5469635\",\n \"0.5468635\",\n \"0.5462949\",\n \"0.5461399\",\n \"0.54491204\",\n \"0.5448523\",\n \"0.5445566\",\n \"0.5444299\",\n \"0.5437646\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55544835"},"document_rank":{"kind":"string","value":"67"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":73,"numItemsPerPage":100,"numTotalItems":95772,"offset":7300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDAwODY4OSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQwMTIyODksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.bJfotyN8CfItN55unRPb_nTYlEqMwC05nxMIEPdADqI2y8evDwvjmAP8LX7Yqzp2XvTyTk3qMieuuBQ5QqKHAw","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 |
|---|---|---|---|---|---|---|
Returns the sum of all priorities stored in this sum tree. | def _total_priority(self):
return self.nodes[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(self) -> int:\n return self.root.sum",
"def sum(self):\n return sum(self.items())",
"def get_sum(self):\n return self.__tree[0]",
"def sum(self):\n return sum(self._values.values())",
"def total_priority(self) -> int:\n return self.tree[0].item()",
"def sum(self... | [
"0.6984377",
"0.67695606",
"0.67609626",
"0.6698405",
"0.6667603",
"0.6662966",
"0.66467816",
"0.66216046",
"0.66216046",
"0.65775466",
"0.6440943",
"0.6387141",
"0.635604",
"0.6329519",
"0.63249815",
"0.6249568",
"0.61827457",
"0.6161957",
"0.61138844",
"0.6100439",
"0.60939... | 0.65628356 | 10 |
Samples an element from the sum tree. | def sample(self, rng, query_value=None):
nodes = jnp.array(self.nodes)
query_value = (
jax.random.uniform(rng) if query_value is None else query_value)
query_value *= self._total_priority()
_, index, _ = jax.lax.fori_loop(0, self.depth, step,
(query_value, 0, nodes))
return np.minimum(index - self.low_idx, self.highest_set) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample(self):\n return self._root.sample()",
"def sample(self) -> None:\n with self._samples_lock:\n if self.element_sampler.has_element:\n self._samples.append(self.element_sampler.el)\n self.element_sampler.has_element = False",
"def sample(self, x):",
"def sample(self):\n ... | [
"0.7230191",
"0.65261966",
"0.63430864",
"0.60525787",
"0.60525787",
"0.60074574",
"0.5991044",
"0.5952631",
"0.59495324",
"0.5881766",
"0.5785147",
"0.57582784",
"0.57345945",
"0.57001364",
"0.5682698",
"0.5620183",
"0.56149185",
"0.56036645",
"0.55956614",
"0.55863214",
"0.... | 0.58518076 | 10 |
Performs stratified sampling using the sum tree. | def stratified_sample(self, batch_size, rng):
if self._total_priority() == 0.0:
raise Exception('Cannot sample from an empty sum tree.')
indices = parallel_stratified_sample(rng, self.nodes, np.arange(batch_size),
batch_size, self.depth)
return np.minimum(indices - self.low_idx, self.highest_set) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample(tree, i, alpha=0.5, beta=0.5, only_tree=True):\n # for n in tree.nodes():\n # lab = tuple(n)\n # if len(n) == 1:\n # lab = \"(\" + str(list(n)[0]) + \")\"\n # tree.node[n] = {\"color\": \"black\", \"label\": lab}\n # print tree.nodes()\n\n if only_tree is True:\n... | [
"0.5792323",
"0.57242346",
"0.5687577",
"0.5676991",
"0.56017643",
"0.55336124",
"0.54666936",
"0.5430783",
"0.53604496",
"0.5358043",
"0.530985",
"0.5304589",
"0.5277224",
"0.5271483",
"0.52695686",
"0.5267166",
"0.5261225",
"0.52445275",
"0.52442276",
"0.5240669",
"0.520557... | 0.76193213 | 0 |
Returns the value of the leaf node corresponding to the index. | def get(self, node_index):
return self.nodes[node_index + self.low_idx] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, index: int) -> int:\n node = self.get_node(index)\n if node:\n return node.val\n else:\n return -1",
"def get_leaf(self, leaf_index):\n return self.__leaves_db.get(encode_int(leaf_index))",
"def _value_at(self, index):\n node = self._get_no... | [
"0.7675132",
"0.75705653",
"0.748514",
"0.748514",
"0.7377657",
"0.7373278",
"0.7160219",
"0.7113328",
"0.70526975",
"0.7030114",
"0.67928636",
"0.66183364",
"0.64346117",
"0.6430315",
"0.64223456",
"0.641513",
"0.63261515",
"0.6309149",
"0.62792677",
"0.62526083",
"0.6249397... | 0.6483467 | 12 |
Sets the value of a leaf node and updates internal nodes accordingly. This operation takes O(log(capacity)). | def set(self, node_index, value):
if value < 0.0:
raise ValueError(
'Sum tree values should be nonnegative. Got {}'.format(value))
self.highest_set = max(node_index, self.highest_set)
node_index = node_index + self.low_idx
self.max_recorded_priority = max(value, self.max_recorded_priority)
delta_value = value - self.nodes[node_index]
# Now traverse back the tree, adjusting all sums along the way.
for _ in reversed(range(self.depth)):
# Note: Adding a delta leads to some tolerable numerical inaccuracies.
self.nodes[node_index] += delta_value
node_index = (node_index - 1) // 2
self.nodes[node_index] += delta_value
assert node_index == 0, ('Sum tree traversal failed, final node index '
'is not 0.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_leaf_node(self, leaf_value):\n\n if not self.empty:\n try:\n node_key = self.node_key\n except AttributeError:\n node_key = '_'\n raise ValueError(\n 'Cannot modify a non-empty node. ' + \\\n 'If you meant to change type of node {}, '.format... | [
"0.7562629",
"0.7099471",
"0.6929827",
"0.6921371",
"0.6896148",
"0.6799146",
"0.67869157",
"0.67869157",
"0.67869157",
"0.6710561",
"0.6672968",
"0.66426194",
"0.6601433",
"0.6589014",
"0.6578079",
"0.6524441",
"0.6495659",
"0.6437595",
"0.64201003",
"0.64104587",
"0.6396286... | 0.63829994 | 21 |
Logs message for given level | def log_message(msg, lvl='info'):
extra = {
'remote_addr': request.remote_addr,
'url': request.url_rule
}
loggers = {
'warning': current_app.logger.warning,
'info': current_app.logger.info,
'debug': current_app.logger.debug,
'error': current_app.logger.error,
'critical': current_app.logger.critical
}
loggers[lvl](msg, extra=extra) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __log(level, message):\n if level == 1:\n logging.info(\" \" + str(datetime.datetime.now()) + \" \" + message)\n if level == 2:\n logging.error(\" \" + str(datetime.datetime.now()) + \" \" + message)\n if level == 3:\n logging.critical(\" \" + str(datetime.datetime.now()) + \" \" ... | [
"0.81246626",
"0.78997695",
"0.78037274",
"0.780287",
"0.7799478",
"0.77843386",
"0.77657396",
"0.77248126",
"0.77185434",
"0.7705718",
"0.76910615",
"0.7610388",
"0.75899214",
"0.7555818",
"0.75395006",
"0.74972963",
"0.74645865",
"0.7456792",
"0.74560916",
"0.7455943",
"0.7... | 0.68746495 | 44 |
Prints a message only when app is in debug mode | def print_debug(message):
if current_app.debug:
print(message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def debug():\n assert current_app.debug == False, \"Don't panic! You're here by request of debug()\"",
"def checkDebug(message):\n if debug == True:\n print(message)",
"def debug(msg):\n if not DEBUG_ON:\n return\n print(\"DEBUG:\" + str(msg))",
"def print_debug(msg):\n if IS_DEB... | [
"0.8137028",
"0.80153483",
"0.77376115",
"0.7687844",
"0.76748055",
"0.767379",
"0.7656623",
"0.7569436",
"0.7528649",
"0.7510831",
"0.7510831",
"0.74950415",
"0.7483869",
"0.74653614",
"0.74565285",
"0.74526405",
"0.7379881",
"0.736538",
"0.734727",
"0.73451245",
"0.734026",... | 0.8150175 | 0 |
Call this function after determining game should end | def endGame(self, message):
print(self.board)
print("Game over! " + message)
self.gameOver = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def endGame(self):\n pass",
"def quit_game(self):\n self.done = True",
"def end_game(self):\n self.game.stop_running()",
"def api_end_game(self):\n pass",
"def end(self, won, reason):\n pass\n # replace with your end logic",
"def endGame(self):\n #self.act... | [
"0.87138814",
"0.78778964",
"0.7744418",
"0.774094",
"0.7740156",
"0.7713625",
"0.76796615",
"0.76591814",
"0.7582613",
"0.75363356",
"0.7433579",
"0.74228734",
"0.7402117",
"0.73863685",
"0.7358601",
"0.7350067",
"0.73360884",
"0.7276998",
"0.72497123",
"0.7248907",
"0.71962... | 0.69771904 | 45 |
Win by reaching the other side | def checkReachWin(self, color, row):
if color[0] == 'W' and row == 0:
self.endGame("White reached the end. White wins!\n")
elif color[0] == 'B' and row == self.board.size - 1:
self.endGame("Black reached the end. Black wins!\n") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def does_move_win(self, x, y):\n me = self.board[x][y]\n for (dx, dy) in [(0, +1), (+1, +1), (+1, 0), (+1, -1)]:\n p = 1\n while self.is_on_board(x+p*dx, y+p*dy) and self.board[x+p*dx][y+p*dy] == me:\n p += 1\n n = 1\n while self.is_on_board(... | [
"0.653839",
"0.65257937",
"0.64947987",
"0.6482304",
"0.6401277",
"0.6380247",
"0.62850153",
"0.6280651",
"0.62673837",
"0.6259922",
"0.6240374",
"0.62018436",
"0.62003434",
"0.61975145",
"0.61953324",
"0.6182207",
"0.61644655",
"0.61555684",
"0.61346805",
"0.61338586",
"0.61... | 0.0 | -1 |
Lose by not having any possible valid moves to make | def checkNoMoveLoss(self, moves):
if not moves:
winner = "Black" if self.turn[0] == "W" else "White"
self.endGame(self.turn + " has nowhere to move. " + winner + " wins!\n") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def any_legal_move(self, player, board):\r\n moves = self.legal_moves(player, board)\r\n #print(moves)\r\n return len(moves)!=0",
"def get_valid_moves(self):\r\n # castling and en-passant rights are stored, because move affects these values\r\n temp_enpassant_possible = self.en... | [
"0.7330048",
"0.7140586",
"0.7039396",
"0.697742",
"0.69300544",
"0.6770414",
"0.676601",
"0.6749859",
"0.66704226",
"0.66598386",
"0.66426575",
"0.66328067",
"0.6632505",
"0.66169274",
"0.6604243",
"0.65838623",
"0.65772635",
"0.6562603",
"0.6525635",
"0.6522035",
"0.6512511... | 0.63703394 | 44 |
Checking string input for format [Row][ColLetter] or [ColLetter][Row] (and not case sensitive) | def parsePosition(self, parse):
if len(parse) == 2:
ch1 = ord(parse[0].lower())
ch2 = ord(parse[1].lower())
maxNum = 48 + self.board.size # ascii of max row #
# [Row#][ColLetter]] case
if 48 < ch1 <= maxNum and 97 <= ch2 < (97 + self.board.size):
return maxNum - ch1, ch2 - 97 # actual grid indexes of desired position
# [ColLetter][Row#] case
if 48 < ch2 <= maxNum and 97 <= ch1 < (97 + self.board.size):
return maxNum - ch2, ch1 - 97 # actual grid indexes of desired position
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_valid_row_or_col(val: str):\n try:\n val = int(val)\n if 1 <= val <= 10:\n return True\n return False\n except (ValueError, TypeError):\n return False",
"def must_contain_letter(cell):\n # Check if it's nan first\n if check_empty(cell):\n return Tr... | [
"0.62249833",
"0.6188426",
"0.6152934",
"0.59214056",
"0.58721745",
"0.5853586",
"0.5825021",
"0.5805107",
"0.5749606",
"0.57305473",
"0.5700164",
"0.5682207",
"0.565165",
"0.5625806",
"0.55352753",
"0.55241305",
"0.5514427",
"0.54875064",
"0.5479798",
"0.5474993",
"0.5458025... | 0.5664392 | 12 |
Returns a string of the possible moves a pawn can make | def suggestMoves(self, startLoc, moves, hasCapture):
suggest = ""
for move in moves[startLoc]:
if hasCapture:
if moves[startLoc][move] == "capture":
suggest += chr(move[1] + 97) + str(self.board.size - move[0]) + " "
else:
suggest += chr(move[1] + 97) + str(self.board.size - move[0]) + " "
return suggest | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def legal_moves():\n\tlegal_moves = (\"r\", \"p\", \"s\")\n\treturn legal_moves",
"def legal_moves(self):\n moves = \"\"\n swappable = self.swappable_positions\n empty_position = self.get_position(0)\n\n for s in swappable:\n pos_diff = empty_position[0] - s[0], empty_posit... | [
"0.75860536",
"0.7416093",
"0.7053937",
"0.69375557",
"0.68239874",
"0.67419034",
"0.6697224",
"0.6633449",
"0.6593096",
"0.6580948",
"0.6536958",
"0.65312415",
"0.6490962",
"0.64726305",
"0.64582986",
"0.6440909",
"0.6390071",
"0.6388789",
"0.6385916",
"0.6381437",
"0.637102... | 0.5896593 | 60 |
This function will optionally print a header guard for `cl_khr_fp64` if a 64bit type is used as the source or destination and return a bool that indicates whether this guard will need closed after the calling function has finished printing functions that use the 64bit source/destination type. | def conditional_guard(src, dst):
int64_count = 0
float64_count = 0
float16_count = 0
if src in int64_types or dst in int64_types:
int64_count = 1
if src in float64_types or dst in float64_types:
float64_count = 1
if src in float16_types or dst in float16_types:
float16_count = 1
if float16_count > 0:
print("#ifdef cl_khr_fp16")
if float64_count > 0:
#In embedded profile, if cl_khr_fp64 is supported cles_khr_int64 has to be
print("#ifdef cl_khr_fp64")
return 1 + float16_count
elif int64_count > 0:
print("#if defined cles_khr_int64 || !defined(__EMBEDDED_PROFILE__)")
return 1 + float16_count
return float16_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_64_windows():\n return struct.calcsize('P') * 8 == 64",
"def have_binary128():\n try:\n ti = type_info(np.longdouble)\n except FloatingError:\n return False\n return (ti['nmant'], ti['maxexp']) == (112, 16384)",
"def is_H(self):\n return True",
"def is_H(self):\n ... | [
"0.4971328",
"0.46334147",
"0.46194386",
"0.46194386",
"0.4604871",
"0.4570718",
"0.45214003",
"0.45135522",
"0.44693208",
"0.44124466",
"0.44066575",
"0.44048572",
"0.43934348",
"0.43365443",
"0.42555895",
"0.4250501",
"0.42504188",
"0.42486706",
"0.42251563",
"0.4212047",
"... | 0.59550357 | 0 |
This function will close conditional guard opened by conditional_guard. | def close_conditional_guard(close_conditional):
for _ in range(close_conditional):
print("#endif") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __exit__(self, type, value, traceback) :\n if self.spec :\n self.handle.close()\n self.handle = None",
"def __exit__(self, type, value, traceback):\n self._conn.close()\n if self._mode == 'w' and self.__special_exit != 'lock exists':\n if os.path.exists('%s_l... | [
"0.6132105",
"0.6084127",
"0.6026904",
"0.59685796",
"0.59367067",
"0.5921348",
"0.5896142",
"0.5895424",
"0.5871011",
"0.5860161",
"0.5860161",
"0.5860161",
"0.5860161",
"0.58590287",
"0.58513856",
"0.58342",
"0.58342",
"0.58342",
"0.58342",
"0.58342",
"0.582248",
"0.58066... | 0.6058337 | 2 |
This helper function returns the correct clc core conversion function name for a given source and destination type, with optional size, mode and saturation arguments. | def clc_core_fn_name(dst, size='', mode='', sat=''):
return "__clc_convert_{DST}{N}{SAT}{MODE}".format(DST=dst, N=size, SAT=sat, MODE=mode) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def src_get_name(converter_type):\n return ffi.string(_lib.src_get_name(converter_type)).decode()",
"def cython_funcname(self, name, argkinds=None):\n if isinstance(name, basestring):\n return name\n if argkinds is None:\n argkinds = [(Arg.NONE, None)] * (len(name) - 1)\n ... | [
"0.58428967",
"0.5695806",
"0.56170404",
"0.5537308",
"0.54060704",
"0.5312154",
"0.52636075",
"0.5209674",
"0.5179819",
"0.5158412",
"0.5142017",
"0.51086265",
"0.50943804",
"0.5006753",
"0.5005477",
"0.5003055",
"0.49839967",
"0.4969238",
"0.49600613",
"0.49500346",
"0.4889... | 0.80150145 | 0 |
Initilize Style MelGAN generator. | def __init__(
self,
in_channels=128,
aux_channels=80,
channels=64,
out_channels=1,
kernel_size=9,
dilation=2,
bias=True,
noise_upsample_scales=[11, 2, 2, 2],
noise_upsample_activation="LeakyReLU",
noise_upsample_activation_params={"negative_slope": 0.2},
upsample_scales=[2, 2, 2, 2, 2, 2, 2, 2, 1],
upsample_mode="nearest",
gated_function="softmax",
use_weight_norm=True,
):
super().__init__()
self.in_channels = in_channels
noise_upsample = []
in_chs = in_channels
for noise_upsample_scale in noise_upsample_scales:
# NOTE(kan-bayashi): How should we design noise upsampling part?
noise_upsample += [
torch.nn.ConvTranspose1d(
in_chs,
channels,
noise_upsample_scale * 2,
stride=noise_upsample_scale,
padding=noise_upsample_scale // 2 + noise_upsample_scale % 2,
output_padding=noise_upsample_scale % 2,
bias=bias,
)
]
noise_upsample += [
getattr(torch.nn, noise_upsample_activation)(
**noise_upsample_activation_params
)
]
in_chs = channels
self.noise_upsample = torch.nn.Sequential(*noise_upsample)
self.noise_upsample_factor = np.prod(noise_upsample_scales)
self.blocks = torch.nn.ModuleList()
aux_chs = aux_channels
for upsample_scale in upsample_scales:
self.blocks += [
TADEResBlock(
in_channels=channels,
aux_channels=aux_chs,
kernel_size=kernel_size,
dilation=dilation,
bias=bias,
upsample_factor=upsample_scale,
upsample_mode=upsample_mode,
gated_function=gated_function,
),
]
aux_chs = channels
self.upsample_factor = np.prod(upsample_scales)
self.output_conv = torch.nn.Sequential(
torch.nn.Conv1d(
channels,
out_channels,
kernel_size,
1,
bias=bias,
padding=(kernel_size - 1) // 2,
),
torch.nn.Tanh(),
)
# apply weight norm
if use_weight_norm:
self.apply_weight_norm()
# reset parameters
self.reset_parameters() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def model_setup(self):\n self.DNN = SganMLP(self.settings.number_of_bins)\n self.D = SganMLP(self.settings.number_of_bins)\n self.G = Generator()",
"def model_setup(self):\n self.DNN = DgganMLP(self.settings.hidden_size)\n self.D = DgganMLP(self.settings.hidden_size)\n s... | [
"0.70487845",
"0.644251",
"0.63743216",
"0.6038303",
"0.5973697",
"0.59719676",
"0.5944061",
"0.5878216",
"0.5834873",
"0.58195704",
"0.5817429",
"0.5784765",
"0.5783701",
"0.577011",
"0.57584363",
"0.57117826",
"0.5703821",
"0.5685936",
"0.5671047",
"0.5652533",
"0.5648202",... | 0.0 | -1 |
Remove weight normalization module from all of the layers. | def remove_weight_norm(self):
def _remove_weight_norm(m):
try:
logging.debug(f"Weight norm is removed from {m}.")
torch.nn.utils.remove_weight_norm(m)
except ValueError: # this module didn't have weight norm
return
self.apply(_remove_weight_norm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_norms(module_: \"WN\") -> \"WN\":\n module_.start = torch.nn.utils.remove_weight_norm(module_.start_conv)\n module_.cond_layer = torch.nn.utils.remove_weight_norm(module_.cond_layer)\n for i, layer_ in enumerate(module_.in_layers):\n layer_ = DepthwiseSeparableConv1d.remo... | [
"0.79998016",
"0.76628864",
"0.7629923",
"0.72848314",
"0.7045166",
"0.67848754",
"0.6780856",
"0.6746634",
"0.6591088",
"0.65823525",
"0.6566755",
"0.65617",
"0.65572643",
"0.65561306",
"0.6538293",
"0.6538293",
"0.6538293",
"0.6529808",
"0.6526071",
"0.651576",
"0.64801204"... | 0.7893102 | 2 |
Apply weight normalization module from all of the layers. | def apply_weight_norm(self):
def _apply_weight_norm(m):
if isinstance(m, torch.nn.Conv1d) or isinstance(
m, torch.nn.ConvTranspose1d
):
torch.nn.utils.weight_norm(m)
logging.debug(f"Weight norm is applied to {m}.")
self.apply(_apply_weight_norm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.B... | [
"0.7143955",
"0.7143955",
"0.7143955",
"0.71335757",
"0.7069364",
"0.7069364",
"0.70534694",
"0.7049442",
"0.70303166",
"0.6807604",
"0.6779128",
"0.6764302",
"0.67596924",
"0.6736109",
"0.6710482",
"0.66960436",
"0.6584008",
"0.6554928",
"0.6526808",
"0.65179425",
"0.6516647... | 0.73184675 | 1 |
Register stats for denormalization as buffer. | def register_stats(self, stats):
assert stats.endswith(".h5") or stats.endswith(".npy")
if stats.endswith(".h5"):
mean = read_hdf5(stats, "mean").reshape(-1)
scale = read_hdf5(stats, "scale").reshape(-1)
else:
mean = np.load(stats)[0].reshape(-1)
scale = np.load(stats)[1].reshape(-1)
self.register_buffer("mean", torch.from_numpy(mean).float())
self.register_buffer("scale", torch.from_numpy(scale).float())
logging.info("Successfully registered stats as buffer.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _cast_buffers(self,\n dtype: Optional[torch.dtype] = None,\n memo: Optional[Set] = None) -> None:\n if memo is None:\n memo = set()\n for module in self.modules():\n if module is not self and isinstance(module, XlaFullyShardedDataParallel):\n # Allow... | [
"0.51819456",
"0.5043784",
"0.49926385",
"0.4946909",
"0.49447924",
"0.49344134",
"0.4884747",
"0.4879836",
"0.48627967",
"0.48563662",
"0.48147842",
"0.47965068",
"0.478542",
"0.47853506",
"0.47853506",
"0.47853506",
"0.47518125",
"0.4747054",
"0.47394067",
"0.47262183",
"0.... | 0.67643166 | 0 |
Initilize Style MelGAN discriminator. | def __init__(
self,
repeats=2,
window_sizes=[512, 1024, 2048, 4096],
pqmf_params=[
[1, None, None, None],
[2, 62, 0.26700, 9.0],
[4, 62, 0.14200, 9.0],
[8, 62, 0.07949, 9.0],
],
discriminator_params={
"out_channels": 1,
"kernel_sizes": [5, 3],
"channels": 16,
"max_downsample_channels": 512,
"bias": True,
"downsample_scales": [4, 4, 4, 1],
"nonlinear_activation": "LeakyReLU",
"nonlinear_activation_params": {"negative_slope": 0.2},
"pad": "ReflectionPad1d",
"pad_params": {},
},
use_weight_norm=True,
):
super().__init__()
# window size check
assert len(window_sizes) == len(pqmf_params)
sizes = [ws // p[0] for ws, p in zip(window_sizes, pqmf_params)]
assert len(window_sizes) == sum([sizes[0] == size for size in sizes])
self.repeats = repeats
self.window_sizes = window_sizes
self.pqmfs = torch.nn.ModuleList()
self.discriminators = torch.nn.ModuleList()
for pqmf_param in pqmf_params:
d_params = copy.deepcopy(discriminator_params)
d_params["in_channels"] = pqmf_param[0]
if pqmf_param[0] == 1:
self.pqmfs += [torch.nn.Identity()]
else:
self.pqmfs += [PQMF(*pqmf_param)]
self.discriminators += [BaseDiscriminator(**d_params)]
# apply weight norm
if use_weight_norm:
self.apply_weight_norm()
# reset parameters
self.reset_parameters() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n super(Discriminator, self).__init__()\n\n # Use stride in convolutions to downsample image to size 1\n\n # Using BatchNorm2d 0.8 for stability based on reading of https://github.com/eriklindernoren/PyTorch-GAN code\n layers = [nn.Conv2d(512, 1, kernel_size=4, strid... | [
"0.67468584",
"0.62949085",
"0.6285982",
"0.62006986",
"0.6102082",
"0.60385245",
"0.6021358",
"0.60148615",
"0.60062915",
"0.5981237",
"0.59416723",
"0.590252",
"0.5898757",
"0.5888632",
"0.58052456",
"0.5799055",
"0.5795089",
"0.5771385",
"0.5755582",
"0.5748591",
"0.572184... | 0.0 | -1 |
Apply weight normalization module from all of the layers. | def apply_weight_norm(self):
def _apply_weight_norm(m):
if isinstance(m, torch.nn.Conv1d) or isinstance(
m, torch.nn.ConvTranspose1d
):
torch.nn.utils.weight_norm(m)
logging.debug(f"Weight norm is applied to {m}.")
self.apply(_apply_weight_norm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.B... | [
"0.71435213",
"0.71435213",
"0.71435213",
"0.7134102",
"0.70675933",
"0.70675933",
"0.70535696",
"0.7048801",
"0.70298284",
"0.6807073",
"0.67789346",
"0.6764012",
"0.6759336",
"0.67359823",
"0.671116",
"0.6696031",
"0.6583814",
"0.6554803",
"0.65268165",
"0.65178454",
"0.651... | 0.7316938 | 2 |
Initilize Style MelGAN generator. | def __init__(
self,
in_channels=128,
aux_channels=128,
channels=64,
out_channels=1,
num_embs=100,
num_spk_embs=128,
spk_emb_dim=128,
concat_spk_emb=False,
kernel_size=9,
dilation=2,
bias=True,
noise_upsample_scales=[11, 2, 2, 2],
noise_upsample_activation="LeakyReLU",
noise_upsample_activation_params={"negative_slope": 0.2},
upsample_scales=[2, 2, 2, 2, 2, 2, 2, 2, 1],
upsample_mode="nearest",
gated_function="softmax",
use_weight_norm=True,
):
super().__init__()
self.in_channels = in_channels
# define id embedding
self.emb = torch.nn.Embedding(
num_embeddings=num_embs, embedding_dim=aux_channels
)
self.spk_emb = torch.nn.Embedding(
num_embeddings=num_spk_embs, embedding_dim=spk_emb_dim
)
self.concat_spk_emb = concat_spk_emb
if not concat_spk_emb:
assert aux_channels == spk_emb_dim
else:
aux_channels = aux_channels + spk_emb_dim
noise_upsample = []
in_chs = in_channels
for noise_upsample_scale in noise_upsample_scales:
# NOTE(kan-bayashi): How should we design noise upsampling part?
noise_upsample += [
torch.nn.ConvTranspose1d(
in_chs,
channels,
noise_upsample_scale * 2,
stride=noise_upsample_scale,
padding=noise_upsample_scale // 2 + noise_upsample_scale % 2,
output_padding=noise_upsample_scale % 2,
bias=bias,
)
]
noise_upsample += [
getattr(torch.nn, noise_upsample_activation)(
**noise_upsample_activation_params
)
]
in_chs = channels
self.noise_upsample = torch.nn.Sequential(*noise_upsample)
self.noise_upsample_factor = np.prod(noise_upsample_scales)
self.blocks = torch.nn.ModuleList()
aux_chs = aux_channels
for upsample_scale in upsample_scales:
self.blocks += [
TADEResBlock(
in_channels=channels,
aux_channels=aux_chs,
kernel_size=kernel_size,
dilation=dilation,
bias=bias,
upsample_factor=upsample_scale,
upsample_mode=upsample_mode,
gated_function=gated_function,
),
]
aux_chs = channels
self.upsample_factor = np.prod(upsample_scales)
self.output_conv = torch.nn.Sequential(
torch.nn.Conv1d(
channels,
out_channels,
kernel_size,
1,
bias=bias,
padding=(kernel_size - 1) // 2,
),
torch.nn.Tanh(),
)
# apply weight norm
if use_weight_norm:
self.apply_weight_norm()
# reset parameters
self.reset_parameters() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def model_setup(self):\n self.DNN = SganMLP(self.settings.number_of_bins)\n self.D = SganMLP(self.settings.number_of_bins)\n self.G = Generator()",
"def model_setup(self):\n self.DNN = DgganMLP(self.settings.hidden_size)\n self.D = DgganMLP(self.settings.hidden_size)\n s... | [
"0.70491105",
"0.64428604",
"0.637395",
"0.6040094",
"0.5974412",
"0.5972569",
"0.59458107",
"0.5878243",
"0.5834997",
"0.58195186",
"0.5818394",
"0.57847136",
"0.5784305",
"0.57710445",
"0.5760498",
"0.57129806",
"0.57045466",
"0.5686031",
"0.56733465",
"0.56541693",
"0.5648... | 0.0 | -1 |
Remove weight normalization module from all of the layers. | def remove_weight_norm(self):
def _remove_weight_norm(m):
try:
logging.debug(f"Weight norm is removed from {m}.")
torch.nn.utils.remove_weight_norm(m)
except ValueError: # this module didn't have weight norm
return
self.apply(_remove_weight_norm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_norms(module_: \"WN\") -> \"WN\":\n module_.start = torch.nn.utils.remove_weight_norm(module_.start_conv)\n module_.cond_layer = torch.nn.utils.remove_weight_norm(module_.cond_layer)\n for i, layer_ in enumerate(module_.in_layers):\n layer_ = DepthwiseSeparableConv1d.remo... | [
"0.79998016",
"0.76628864",
"0.7629923",
"0.72848314",
"0.7045166",
"0.67848754",
"0.6780856",
"0.6746634",
"0.6591088",
"0.65823525",
"0.6566755",
"0.65617",
"0.65572643",
"0.65561306",
"0.6538293",
"0.6538293",
"0.6538293",
"0.6529808",
"0.6526071",
"0.651576",
"0.64801204"... | 0.7893102 | 1 |
Apply weight normalization module from all of the layers. | def apply_weight_norm(self):
def _apply_weight_norm(m):
if isinstance(m, torch.nn.Conv1d) or isinstance(
m, torch.nn.ConvTranspose1d
):
torch.nn.utils.weight_norm(m)
logging.debug(f"Weight norm is applied to {m}.")
self.apply(_apply_weight_norm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_weights(self):\n for layer in self.modules():\n if isinstance(layer, (nn.Conv1d, nn.Linear)):\n nn.init.xavier_uniform_(layer.weight)\n if layer.bias is not None:\n nn.init.constant_(layer.bias, 0)\n elif isinstance(layer, nn.B... | [
"0.71430475",
"0.71430475",
"0.71430475",
"0.713435",
"0.70688635",
"0.70688635",
"0.7052796",
"0.7049518",
"0.70298177",
"0.68070155",
"0.6778134",
"0.676388",
"0.6760103",
"0.67364126",
"0.6710347",
"0.6696243",
"0.65825963",
"0.65547544",
"0.6525561",
"0.6517765",
"0.65163... | 0.73182416 | 0 |
Load csv data into pandas | def load_data(filename):
# Load the necessary columns from the csv into pandas
data = pd.read_csv(filename, sep=';')
# Cleans the data
data = data[["Perioden", "Regio's",\
"Kerkelijke gezindte/Geen kerkelijke gezindte (% van de bevolking)",\
"Kerkelijke gezindte/Totaal kerkelijke gezindte (% van de bevolking)",\
"Kerkelijke gezindte/Rooms-Katholiek (% van de bevolking)",\
"Kerkelijke gezindte/Protestantse Kerk in Nederland (% van de bevolking)",\
"Kerkelijke gezindte/Nederlands Hervormd (% van de bevolking)",\
"Kerkelijke gezindte/Gereformeerd (% van de bevolking)",\
"Kerkelijke gezindte/Islam (% van de bevolking)",\
"Kerkelijke gezindte/Overige gezindte (% van de bevolking)"]]
# Creates new columns for renaming purposes
data["Year"] = data["Perioden"]
data["Region"] = data["Regio's"]
data["Athiest"] = data["Kerkelijke gezindte/Geen kerkelijke gezindte (% van de bevolking)"]
data["Total"] = data["Kerkelijke gezindte/Totaal kerkelijke gezindte (% van de bevolking)"]
data["Roman Catholic"] = data["Kerkelijke gezindte/Rooms-Katholiek (% van de bevolking)"]
data["Protestant"] = data["Kerkelijke gezindte/Protestantse Kerk in Nederland (% van de bevolking)"]
data["Dutch Reformed"] = data["Kerkelijke gezindte/Nederlands Hervormd (% van de bevolking)"]
data["Reformed"] = data["Kerkelijke gezindte/Gereformeerd (% van de bevolking)"]
data["Islam"] = data["Kerkelijke gezindte/Islam (% van de bevolking)"]
data["Other"] = data["Kerkelijke gezindte/Overige gezindte (% van de bevolking)"]
# Deletes doubles
data.drop(data.columns[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], axis = 1, inplace=True)
data = data.set_index("Region")
print(data)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_from_csv(self, filepath):\n self.dataframe = pd.load_csv(filepath, separator='')",
"def load_data(csv_path):\n df = pd.read_csv(csv_path)\n return df",
"def _parse_csv(csv_file: str) -> pd.DataFrame:\n return pd.read_csv(csv_file, header=0)",
"def load_from_csv(path, delimiter=',... | [
"0.7997091",
"0.76976955",
"0.7580888",
"0.75562894",
"0.7530883",
"0.75125337",
"0.7335565",
"0.7333322",
"0.73209023",
"0.72114277",
"0.7200636",
"0.71992266",
"0.7190701",
"0.71325487",
"0.7120215",
"0.71044284",
"0.7094358",
"0.7092082",
"0.7048781",
"0.70392513",
"0.7030... | 0.0 | -1 |
Start Spark, define config and path to test data | def setUp(self):
self.test_data_path = 'testing/test_data/' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n self.spark, self.log, self.config = start_spark(app_name = \"test_etl_job\",\n files='configs/etl_config.json')",
"def setUp(self):\n with open(SRC_PATH + \"configs/etl_config.json\", \"r\") as f:\n self.config = j... | [
"0.77397996",
"0.70026386",
"0.68174267",
"0.68167377",
"0.6324946",
"0.632194",
"0.63131744",
"0.62284076",
"0.61973965",
"0.6191538",
"0.615016",
"0.61465317",
"0.6010293",
"0.5978047",
"0.59729236",
"0.59613144",
"0.59418756",
"0.5929893",
"0.5851277",
"0.5777042",
"0.5773... | 0.50840384 | 79 |
Write to file or write to db | def on_data(self, tweet):
if (time.time() - self.start_time) < self.limit:
self.saveFile.write(tweet)
return True
else:
self.saveFile.close()
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, **kwargs):\n # First, attempt to update the local store\n self.update()\n # Only get here if the file doesn't already exist\n with open(self._db_file, 'w') as fp:\n json.dump(self.to_dict(\"JSON\"), fp, **kwargs)",
"def writedb(path, key, value) -> int:\n ... | [
"0.6699802",
"0.6676422",
"0.65458137",
"0.6534973",
"0.6344988",
"0.6320584",
"0.6263552",
"0.62094015",
"0.62065643",
"0.6195185",
"0.61912936",
"0.61912936",
"0.6186057",
"0.6150113",
"0.6143777",
"0.6141619",
"0.6129302",
"0.61252534",
"0.61246955",
"0.61167467",
"0.61080... | 0.0 | -1 |
Authenticate, define interested topics to search, define running mode | def __init__(self, topics=None, tweet_file=None, mode='batch'):
self.topics = topics
# (The twitter API will only return a max of 100 count)
self.GEN_MAX_TWEET = 100 # the max number of tweets to generate
self.tweet_file = tweet_file
self.mode = mode
self.tweets = []
if topics and tweet_file:
print("WARNING! you input both topics and the tweet file, only one is expected")
exit(-1)
if not topics and not tweet_file:
print("WARNING! you input either topics or tweet file, one is expected")
exit(-1)
# If file argument is given, it will not connect to twitter server
# It will just save tweets in self.tweets
if tweet_file:
with open(tweet_file, 'r') as infile:
for line in infile:
self.tweets.append(json.loads(line))
else:
consumer_key = 'bbqKfXEU2VJNoWlYJvbdtptOE'
consumer_secret = 'afPk2JuMMMD6IhP5Xijo60ni4FUK39PDzhU7ylgT9FgNZX9ngh'
access_token = '434708489-DTeHfK4OYKRuIXlfoWnNgzzwpEZTPCEpSMv8C0ll'
access_token_secret = 'SjWFYfX2k3q4RJKQXcP1LP9ikhRfckPKOEcrb2cpQ0A0n'
# Attempt authentication
try:
# create OAuthHandler object
self.auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
# set access token and secret
self.auth.set_access_token(access_token, access_token_secret)
# create tweepy API object to fetch tweets
self.api = tweepy.API(self.auth)
except:
print("Error: Authentication Failed")
exit(-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_topic_retrieval_authenticated(self):\n self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.free_token.key)\n response = self.client.get('/topics/', format='json')\n data = json.loads(response.content)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n ... | [
"0.6053095",
"0.58813876",
"0.5666131",
"0.557826",
"0.5459492",
"0.53823984",
"0.532111",
"0.532111",
"0.5253463",
"0.5241494",
"0.52394074",
"0.5199479",
"0.51915526",
"0.5182518",
"0.51710373",
"0.5163896",
"0.51167077",
"0.5087796",
"0.50840545",
"0.5075657",
"0.5069533",... | 0.0 | -1 |
Limit the request sent to twitter server | def limit_handled(cursor):
# TODO: possibly need this function to limit request frequency
while True:
try:
yield cursor.next()
except tweepy.RateLimitError:
time.sleep(60) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def streamTweets(words = [], authors = [], timeLimit=120, removeRetweets=False, **kwargs):\n if 'stream' not in globals():\n global stream\n if 'api' not in globals():\n startTwitterApi(getApiKeys(fileName=\"apiConf2.txt\"))\n listener = StdOutListener(removeRetweets=removeRetwee... | [
"0.6198629",
"0.6029169",
"0.58477575",
"0.5808274",
"0.57665455",
"0.57665455",
"0.5764181",
"0.56391084",
"0.56317997",
"0.5610845",
"0.56010497",
"0.5593688",
"0.559113",
"0.5582899",
"0.5582899",
"0.5582899",
"0.5582899",
"0.5582672",
"0.5578223",
"0.55680096",
"0.5566374... | 0.558243 | 18 |
Returns a humanized rstring representing time difference between now() and the input timestamp. The output rounds up to days, hours, minutes, or seconds. 4 days 5 hours returns '4 days' 0 days 4 hours 3 minutes returns '4 hours', etc... | def time_since(timestamp=None):
rstr = ""
if not timestamp or not isinstance(timestamp, datetime.datetime):
return rstr
now = timezone.now()
timediff = now - timestamp
days = timediff.days
weeks = days//7
months = days//30
minutes = timediff.seconds % 3600 // 60
seconds = timediff.seconds % 3600 % 60
hours = minutes // 60
if days > 365:
return "> a year"
if months > 0:
if months == 1:
tstr = "month"
else:
tstr = "months"
rstr = rstr + "%s %s" % (months, tstr)
return rstr
if weeks > 0:
if weeks == 1:
tstr = "week"
else:
tstr = "weeks"
rstr = rstr + "%s %s" % (weeks, tstr)
return rstr
if days > 0:
if days == 1:
tstr = "day"
else:
tstr = "days"
rstr = rstr + "%s %s" % (days, tstr)
return rstr
elif hours > 0:
if hours == 1:
tstr = "hour"
else:
tstr = "hours"
rstr = rstr + "%s %s" % (hours, tstr)
return rstr
elif minutes > 0:
if minutes == 1:
tstr = "min"
else:
tstr = "mins"
rstr = rstr + "%s %s" % (minutes, tstr)
return rstr
elif seconds > 0:
if seconds == 1:
tstr = "sec"
else:
tstr = "secs"
rstr = rstr + "%s %s" % (seconds, tstr)
return rstr
else:
return "Now" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def humanize_ts(timestamp=False):\n now = datetime.now()\n diff = now - datetime.fromtimestamp(timestamp)\n second_diff = diff.seconds\n day_diff = diff.days\n\n if day_diff < 0:\n return ''\n\n if day_diff == 0:\n if second_diff < 10:\n return \"just now\"\n if se... | [
"0.7199235",
"0.6999816",
"0.6862485",
"0.6823745",
"0.6743255",
"0.6654757",
"0.66247755",
"0.65492713",
"0.64874226",
"0.64806837",
"0.6469421",
"0.64674145",
"0.64304537",
"0.6402844",
"0.6387063",
"0.6360706",
"0.6358006",
"0.6357516",
"0.63572836",
"0.63446885",
"0.63081... | 0.7168039 | 1 |
Wigner Ville Distribution and PseudoWigner Ville Distribution. | def wvd(signal, sampling_rate=1000, n_freqbins=None, analytical_signal=True, method="WignerVille"):
# Compute the analytical signal
if analytical_signal:
signal = scipy.signal.hilbert(signal_detrend(signal))
# Pre-processing
if n_freqbins is None:
n_freqbins = 256
if method in ["pseudoWignerVille", "pwvd"]:
fwindows = np.zeros(n_freqbins + 1)
fwindows_mpts = len(fwindows) // 2
windows_length = n_freqbins // 4
windows_length = windows_length - windows_length % 2 + 1
windows = np.hamming(windows_length)
fwindows[fwindows_mpts + np.arange(-windows_length // 2, windows_length // 2)] = windows
else:
fwindows = np.ones(n_freqbins + 1)
fwindows_mpts = len(fwindows) // 2
time = np.arange(len(signal)) * 1.0 / sampling_rate
# This is discrete frequency (should we return?)
if n_freqbins % 2 == 0:
frequency = np.hstack((np.arange(n_freqbins / 2), np.arange(-n_freqbins / 2, 0)))
else:
frequency = np.hstack(
(np.arange((n_freqbins - 1) / 2), np.arange(-(n_freqbins - 1) / 2, 0))
)
tfr = np.zeros((n_freqbins, time.shape[0]), dtype=complex) # the time-frequency matrix
tausec = round(n_freqbins / 2.0)
winlength = tausec - 1
# taulens: len of tau for each step
taulens = np.min(
np.c_[
np.arange(signal.shape[0]),
signal.shape[0] - np.arange(signal.shape[0]) - 1,
winlength * np.ones(time.shape),
],
axis=1,
)
conj_signal = np.conj(signal)
# iterate and compute the wv for each indices
for idx in range(time.shape[0]):
tau = np.arange(-taulens[idx], taulens[idx] + 1).astype(int)
# this step is required to use the efficient DFT
indices = np.remainder(n_freqbins + tau, n_freqbins).astype(int)
tfr[indices, idx] = (
fwindows[fwindows_mpts + tau] * signal[idx + tau] * conj_signal[idx - tau]
)
if (idx < signal.shape[0] - tausec) and (idx >= tausec + 1):
tfr[tausec, idx] = (
fwindows[fwindows_mpts + tausec]
* signal[idx + tausec]
* np.conj(signal[idx - tausec])
+ fwindows[fwindows_mpts - tausec]
* signal[idx - tausec]
* conj_signal[idx + tausec]
)
tfr[tausec, idx] *= 0.5
# Now tfr contains the product of the signal segments and its conjugate.
# To find wd we need to apply fft one more time.
tfr = np.fft.fft(tfr, axis=0)
tfr = np.real(tfr)
# continuous time frequency
frequency = 0.5 * np.arange(n_freqbins, dtype=float) / n_freqbins * sampling_rate
return frequency, time, tfr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wpi(nev,mu):\n return np.sqrt(nev*eV2J**2/(mp*mu*epsilon));",
"def test_wignerVille(self):\n datafile = os.path.join(os.path.dirname(__file__), 'data', 'wv.npz')\n rec = np.load(datafile)\n wv = abs(wigner_ville_spectrum(\n signal_bursts(), 10, 3.5, smoothing_filter='gauss'... | [
"0.61289203",
"0.5875487",
"0.58468914",
"0.5686039",
"0.56515056",
"0.56493896",
"0.5648032",
"0.56267035",
"0.5614728",
"0.5562713",
"0.5514241",
"0.5454711",
"0.5417939",
"0.54137903",
"0.53736",
"0.53622884",
"0.53448796",
"0.5342925",
"0.5333436",
"0.53204405",
"0.528870... | 0.0 | -1 |
Smoothed Pseudo Wigner Ville Distribution | def smooth_pseudo_wvd(
signal,
sampling_rate=1000,
freq_length=None,
time_length=None,
segment_step=1,
nfreqbin=None,
window_method="hamming",
):
# Define parameters
N = len(signal)
# sample_spacing = 1 / sampling_rate
if nfreqbin is None:
nfreqbin = 300
# Zero-padded signal to length 2N
signal_padded = np.append(signal, np.zeros_like(signal))
# DFT
signal_fft = np.fft.fft(signal_padded)
signal_fft[1 : N - 1] = signal_fft[1 : N - 1] * 2
signal_fft[N:] = 0
# Inverse FFT
signal_ifft = np.fft.ifft(signal_fft)
signal_ifft[N:] = 0
# Make analytic signal
signal = scipy.signal.hilbert(signal_detrend(signal_ifft))
# Create smoothing windows in time and frequency
if freq_length is None:
freq_length = np.floor(N / 4.0)
# Plus one if window length is not odd
if freq_length % 2 == 0:
freq_length += 1
elif len(freq_length) % 2 == 0:
raise ValueError("The length of frequency smoothing window must be odd.")
if time_length is None:
time_length = np.floor(N / 10.0)
# Plus one if window length is not odd
if time_length % 2 == 0:
time_length += 1
elif len(time_length) % 2 == 0:
raise ValueError("The length of time smoothing window must be odd.")
if window_method == "hamming":
freq_window = scipy.signal.hamming(int(freq_length)) # normalize by max
time_window = scipy.signal.hamming(int(time_length)) # normalize by max
elif window_method == "gaussian":
std_freq = freq_length / (6 * np.sqrt(2 * np.log(2)))
freq_window = scipy.signal.gaussian(freq_length, std_freq)
freq_window /= max(freq_window)
std_time = time_length / (6 * np.sqrt(2 * np.log(2)))
time_window = scipy.signal.gaussian(time_length, std_time)
time_window /= max(time_window)
# to add warning if method is not one of the supported methods
# Mid-point index of windows
midpt_freq = (len(freq_window) - 1) // 2
midpt_time = (len(time_window) - 1) // 2
# Create arrays
time_array = np.arange(start=0, stop=N, step=segment_step, dtype=int) / sampling_rate
# frequency_array = np.fft.fftfreq(nfreqbin, sample_spacing)[0:nfreqbin / 2]
frequency_array = 0.5 * np.arange(nfreqbin, dtype=float) / N
pwvd = np.zeros((nfreqbin, len(time_array)), dtype=complex)
# Calculate pwvd
for i, t in enumerate(time_array):
# time shift
tau_max = np.min(
[t + midpt_time - 1, N - t + midpt_time, np.round(N / 2.0) - 1, midpt_freq]
)
# time-lag list
tau = np.arange(
start=-np.min([midpt_time, N - t]), stop=np.min([midpt_time, t - 1]) + 1, dtype="int"
)
time_pts = (midpt_time + tau).astype(int)
g2 = time_window[time_pts]
g2 = g2 / np.sum(g2)
signal_pts = (t - tau - 1).astype(int)
# zero frequency
pwvd[0, i] = np.sum(g2 * signal[signal_pts] * np.conjugate(signal[signal_pts]))
# other frequencies
for m in range(int(tau_max)):
tau = np.arange(
start=-np.min([midpt_time, N - t - m]),
stop=np.min([midpt_time, t - m - 1]) + 1,
dtype="int",
)
time_pts = (midpt_time + tau).astype(int)
g2 = time_window[time_pts]
g2 = g2 / np.sum(g2)
signal_pt1 = (t + m - tau - 1).astype(int)
signal_pt2 = (t - m - tau - 1).astype(int)
# compute positive half
rmm = np.sum(g2 * signal[signal_pt1] * np.conjugate(signal[signal_pt2]))
pwvd[m + 1, i] = freq_window[midpt_freq + m + 1] * rmm
# compute negative half
rmm = np.sum(g2 * signal[signal_pt2] * np.conjugate(signal[signal_pt1]))
pwvd[nfreqbin - m - 1, i] = freq_window[midpt_freq - m + 1] * rmm
m = np.round(N / 2.0)
if t <= N - m and t >= m + 1 and m <= midpt_freq:
tau = np.arange(
start=-np.min([midpt_time, N - t - m]),
stop=np.min([midpt_time, t - 1 - m]) + 1,
dtype="int",
)
time_pts = (midpt_time + tau + 1).astype(int)
g2 = time_window[time_pts]
g2 = g2 / np.sum(g2)
signal_pt1 = (t + m - tau).astype(int)
signal_pt2 = (t - m - tau).astype(int)
x = np.sum(g2 * signal[signal_pt1] * np.conjugate(signal[signal_pt2]))
x *= freq_window[midpt_freq + m + 1]
y = np.sum(g2 * signal[signal_pt2] * np.conjugate(signal[signal_pt1]))
y *= freq_window[midpt_freq - m + 1]
pwvd[m, i] = 0.5 * (x + y)
pwvd = np.real(np.fft.fft(pwvd, axis=0))
# Visualization
return frequency_array, time_array, pwvd | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _smooth(values, std):\n width = std * 4\n x = np.linspace(-width, width, min(2 * width + 1, len(values)))\n kernel = np.exp(-(x / 5)**2)\n\n values = np.array(values)\n weights = np.ones_like(values)\n\n smoothed_values = np.convolve(values, kernel, mode='same')\n smoothed_weights = np.convolve(weights,... | [
"0.64140326",
"0.602416",
"0.5890475",
"0.5847634",
"0.58306766",
"0.5785613",
"0.57544583",
"0.57424194",
"0.57397753",
"0.57333004",
"0.57170975",
"0.5714303",
"0.5707594",
"0.5699608",
"0.56825364",
"0.5621545",
"0.5603333",
"0.56010664",
"0.5588229",
"0.5582662",
"0.55763... | 0.0 | -1 |
Visualize a timefrequency matrix. | def plot_timefrequency(z, time, f, signal=None, method="stft"):
if method == "stft":
figure_title = "Short-time Fourier Transform Magnitude"
fig, ax = plt.subplots()
for i in range(len(time)):
ax.plot(f, z[:, i], label="Segment" + str(np.arange(len(time))[i] + 1))
ax.legend()
ax.set_title("Signal Spectrogram")
ax.set_ylabel("STFT Magnitude")
ax.set_xlabel("Frequency (Hz)")
elif method == "cwt":
figure_title = "Continuous Wavelet Transform Magnitude"
elif method == "wvd":
figure_title = "Wigner Ville Distrubution Spectrogram"
fig = plt.figure()
plt.plot(time, signal)
plt.xlabel("Time (sec)")
plt.ylabel("Signal")
elif method == "pwvd":
figure_title = "Pseudo Wigner Ville Distribution Spectrogram"
fig, ax = plt.subplots()
spec = ax.pcolormesh(time, f, z, cmap=plt.get_cmap("magma"), shading="auto")
plt.colorbar(spec)
ax.set_title(figure_title)
ax.set_ylabel("Frequency (Hz)")
ax.set_xlabel("Time (sec)")
return fig | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_frequency(self):\n canvas = xboa.common.make_root_canvas(\"frequency vs time\")\n canvas.Draw()\n freq_list = [freq for freq in self.freq_list]\n hist, graph = xboa.common.make_root_graph(\"frequency vs time\",\n self.time_list, ... | [
"0.6815102",
"0.6405556",
"0.6397176",
"0.6318654",
"0.62567717",
"0.62256616",
"0.6137152",
"0.6075933",
"0.603835",
"0.60201347",
"0.6009235",
"0.6006938",
"0.5997316",
"0.5959236",
"0.5952973",
"0.5915869",
"0.58863264",
"0.58826864",
"0.5851976",
"0.5786718",
"0.57783747"... | 0.6246299 | 5 |
return nothing but store data in self.parse_msg and self.parse_type | def parse(self, message, prefix, cmd_list):
self.parse_type = ""
self.parse_msg = []
for i in message:
if i[0].isdigit():
self.parse_number(i, "w")
elif len(i) == 1:
self.parse_type += "w"
self.parse_msg.append(i)
elif i == "@everyone" or i == "@here":
self.parse_type += "s"
self.parse_msg.append(i)
elif i[0] == prefix:
self.parse_command(i, cmd_list)
elif i[0] == "-":
self.parse_number(i, "o")
elif i[0] == "<" and len(i) > 3:
self.parse_mention(i)
else:
self.parse_type += "w"
self.parse_msg.append(i[(i[0] == "\\"):]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(self, data):\n raise NotImplementedError",
"def parse(cls, data):\n raise NotImplementedError",
"def _parse(self):\n pass",
"def parse_data(self):\n\t\traise NotImplementedError('%s: No parse function implemented!' % self.name)",
"def parse(self, message: Message):\n\t\tpass"... | [
"0.7193137",
"0.6979878",
"0.6934807",
"0.6921208",
"0.670192",
"0.66826284",
"0.66826284",
"0.66826284",
"0.66826284",
"0.66752",
"0.66359085",
"0.6599634",
"0.6561199",
"0.6499567",
"0.6447754",
"0.6330373",
"0.6247721",
"0.62246966",
"0.61490583",
"0.61253613",
"0.61129683... | 0.58469677 | 49 |
return elements in the message with given parameters match is the type of elements you want to get (check the parse_type variable to see possibilities) using ! at start of match will reverse the value of positive occurences will create the nth indexes elements to capture None will find everything | def finder(self, match="w", occurences=None, start=None, stop=None, trigger=True, positive=True, reverse=False, keep_prefix=False):
res = []
length = len(self.parse_type)
if occurences != None:
occurences = str(occurences)
index_array = self.indexes(occurences, 1)
is_capturing = (start == None)
target = 0
if match == None:
match = "xwoifmrcs"
if len(match) > 0 and match[0] == "!":
positive = (positive == False)
for idx in range(length*reverse-reverse, length*(-reverse+1)-reverse, (-reverse)*2+1): #xd lol
if is_capturing == False:
if type(start) == type(0):
is_capturing = (idx == start)
else:
is_capturing = (self.parse_type[idx] in start)
if stop != None:
if trigger == True or is_capturing == True:
if type(stop) == type(0) and (idx == stop):
break
if type(stop) == " " and (self.parse_type[idx] in stop):
break
if is_capturing == True:
if (self.parse_type[idx] in match) == positive:
if target in index_array:
res.append(self.parse_msg[idx][(keep_prefix == False and self.parse_type[idx] in "ox"):])
target += 1
if len(res) == 0:
return None
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _any_depth_parse(match):\n markers = [match.p1, match.p2, match.p3, match.p4, match.p5, match.p6]\n for idx in (4, 5):\n if markers[idx]:\n markers[idx] = mtypes.emphasize(markers[idx])\n return [m for m in markers if m]",
"def onNameType(self, match):\n\t\treturn [self.process(mat... | [
"0.5471574",
"0.52397555",
"0.5145322",
"0.5005529",
"0.49990287",
"0.49739963",
"0.49577978",
"0.49357885",
"0.49001318",
"0.48870462",
"0.48827666",
"0.4872868",
"0.48422822",
"0.48398778",
"0.48214757",
"0.4820572",
"0.48020837",
"0.47951323",
"0.4777706",
"0.4765019",
"0.... | 0.5920306 | 0 |
return True if parameters does match the parse_type match is the amount of each parse_type elements you want to search. You can write www to check 3 words in a row ranges follow the same syntax as occurences except it targets indexes | def checker(self, match="xw", ranges="0,1", in_a_row=True, reverse=False):
res = []
length = len(self.parse_type)
if ranges != None:
ranges = str(ranges)
index_array = self.indexes(ranges)
substring = ""
for idx in range(length*reverse-reverse, length*(-reverse+1)-reverse, (-reverse)*2+1): #xd lol
if idx in index_array:
substring += self.parse_type[idx]
if in_a_row == True:
return (match in substring)
if in_a_row == False:
target = 0
for i in substring:
target += (match[target] == i)
return (target == maxi)
if in_a_row == None:
for i in self.parse_type:
if i in match:
match = match.replace(i, '', 1)
return (match == "")
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _match(self, *token_types):\n for token in token_types:\n if self._check(token):\n self._advance()\n return True\n\n return False",
"def _multiindex_row_in(cls, row, parse_list, start=None, stop=None):\n\n row_sub = r... | [
"0.65751725",
"0.56603086",
"0.557421",
"0.5525039",
"0.54756975",
"0.5400486",
"0.53058875",
"0.52834386",
"0.5266304",
"0.5260166",
"0.5238574",
"0.5214264",
"0.5185073",
"0.51797396",
"0.51623565",
"0.5152065",
"0.5134428",
"0.5108154",
"0.5108154",
"0.51043475",
"0.509991... | 0.62283635 | 1 |
Run the unit tests. | def test():
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def runTests(self):\n \n pass",
"def test():\n import unittest\n\n tests = unittest.TestLoader().discover(\"tests\")\n unittest.TextTestRunner(verbosity=2).run(tests)",
"def main():\n run_test_all()",
"def test():\n import unittest\n tests = unittest.TestLoader().dis... | [
"0.85183024",
"0.82517105",
"0.81414855",
"0.8076668",
"0.8069847",
"0.80517304",
"0.8050559",
"0.801922",
"0.7989364",
"0.7988354",
"0.79849315",
"0.7968269",
"0.7955071",
"0.7955071",
"0.79471713",
"0.79471713",
"0.79471713",
"0.7850217",
"0.7809605",
"0.7801223",
"0.777470... | 0.7952072 | 22 |
Processor pool entry point. Responsible for processing and writing one event from the message bus | def process_event(event_processor, event):
log = logging.getLogger(__name__)
try:
log.debug("Processing Event: %s - %s" % (event["content_type"], event["routing_key"]))
event_processor.process_event(event["content_type"], event["routing_key"], event["body"])
except:
log.exception("Unable to process event") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self, event):\n pass",
"def event_queue_proc(self,event):\r\n event()",
"def process_event(self, event):\r\n pass",
"def process_amqp_events(self):\n self.connection.process_data_events()",
"def ProcessEvents(self):\n self.work_queue.put(self.__ProcessEventsAsync)... | [
"0.69330835",
"0.6680876",
"0.654648",
"0.64165616",
"0.6389811",
"0.6374216",
"0.6304277",
"0.628056",
"0.6252483",
"0.6216612",
"0.6205624",
"0.6205508",
"0.61948574",
"0.61800677",
"0.61060655",
"0.6080079",
"0.60410905",
"0.6012227",
"0.6012227",
"0.6012227",
"0.6008976",... | 0.62044877 | 12 |
Determine which EDR events should be sent to forwarder | def on_starting(self):
self.set_capture_events_from_config() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_capture_events_from_config(self):\n\n event_config = [\n {\n \"config_key\": \"events_watchlist\",\n \"events\": [\n \"watchlist.hit.process\",\n \"watchlist.hit.binary\",\n \"watchlist.storage.hit.proc... | [
"0.61217207",
"0.55249405",
"0.55249405",
"0.5509148",
"0.54260296",
"0.53321046",
"0.52999175",
"0.52999175",
"0.5238973",
"0.5216273",
"0.51892865",
"0.51738495",
"0.5165304",
"0.51611227",
"0.5153233",
"0.51480025",
"0.5140899",
"0.51364225",
"0.5098679",
"0.50892186",
"0.... | 0.0 | -1 |
Prepare to process RabbitMQ events and start consuming | def run(self):
self.debug = self.forwarder_options.get("debug", "0") != "0"
if self.debug:
self.logger.setLevel(logging.DEBUG)
processor_count = int(self.forwarder_options.get("message_processor_count", 1))
cpu_count = multiprocessing.cpu_count()
if processor_count > cpu_count:
self.logger.info("processor_count (%s) > cpu_count. Defaulting to cpu_count", (processor_count, cpu_count))
processor_count = cpu_count
self.event_processor = EventProcessor(self.forwarder_options)
self.processor_pool = multiprocessing.Pool(processor_count)
while True:
try:
self.consume_message_bus(test=self.testing)
except Exception as e:
self.retry_attempts += 1
if self.retry_attempts > self.max_retry_attempts:
self.logger.critical("Too many attempts to reconnect (%d). Exiting now." % self.max_retry_attempts)
break
if isinstance(e, pika.exceptions.AMQPConnectionError) or isinstance(e, pika.exceptions.ConnectionClosed):
self.logger.error("Connection is closed or refused, retrying in %s seconds" % self.retry_interval)
else:
self.logger.exception("An unexpected error occurred, retrying in %s seconds" % self.retry_interval)
if self.connection is not None:
self.connection.close()
self.connection = None
time.sleep(self.retry_interval) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_amqp_events(self):\n self.connection.process_data_events()",
"def consume():\n with conn.channel() as chan:\n \n def on_msg_recv(msg):\n \"\"\" Called when message arrives from RabbitMQ\n \"\"\"\n print \"processor|%s::Received message: %s\" % ... | [
"0.7568344",
"0.67390686",
"0.6702978",
"0.6613848",
"0.65698355",
"0.6562793",
"0.65285885",
"0.6489923",
"0.6489923",
"0.6489923",
"0.64743716",
"0.64450294",
"0.63913554",
"0.63741064",
"0.62963545",
"0.62910515",
"0.6283345",
"0.62690264",
"0.6255861",
"0.62298816",
"0.62... | 0.62451327 | 19 |
Close any open resources | def on_stopping(self):
self.logger.info("Got a shutdown of service")
try:
if self.connection is not None:
self.connection.close()
self.connection = None
if self.processor_pool is not None:
self.processor_pool.close()
self.processor_pool.join()
self.debug = self.forwarder_options.get("debug", "0") != "0"
if self.debug:
self.logger.setLevel(logging.DEBUG)
except:
self.logger.exception("Error stopping service") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close():",
"def finalize(self):\n self.ratings.close()\n self.users.close()\n self.movies.close()",
"def close(self):\n for lrms in self.resources.itervalues():\n lrms.close()",
"def do_close(self):\n self.cleanup(True)\n self.close()",
"def close( s... | [
"0.8018784",
"0.78392184",
"0.77499765",
"0.7615301",
"0.7552293",
"0.75487936",
"0.7532097",
"0.75203544",
"0.7515063",
"0.7499064",
"0.7497777",
"0.7487781",
"0.7487781",
"0.7487781",
"0.7487781",
"0.7487781",
"0.7487781",
"0.7487781",
"0.7487781",
"0.7487781",
"0.7487781",... | 0.0 | -1 |
Subscribe to the EDR event bus and begin consuming messages | def consume_message_bus(self, test=False):
if test:
from test_fake_bus import FakeChannel, FakeConnection
self.logger.info("Running Test Message Bus")
self.channel = FakeChannel(self.on_bus_message, self.forwarder_options, self.logger)
self.connection = FakeConnection()
return
username, password = self.get_bus_credentials()
credentials = pika.PlainCredentials(username, password)
parameters = pika.ConnectionParameters(self.cb_server_hostname, 5004, "/", credentials)
self.connection = pika.SelectConnection(parameters, self.bus_on_connected,
on_close_callback=self.bus_on_closed)
self.logger.info("Starting bus connection")
self.retry_attempts = 0
self.connection.ioloop.start() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subscribe(receiver):",
"def subscribe(receiver):",
"def subscribe(receiver):",
"def subscribe(self):\n if hasattr(self.bus, \"signal_handler\"):\n self.bus.signal_handler.subscribe()\n if hasattr(self.bus, \"console_control_handler\"):\n self.bus.console_control_handle... | [
"0.65859115",
"0.65859115",
"0.65859115",
"0.6490624",
"0.63868344",
"0.6325292",
"0.6266391",
"0.62001973",
"0.6125916",
"0.60468745",
"0.6021934",
"0.6003453",
"0.59971917",
"0.5954995",
"0.59471166",
"0.59357494",
"0.5932107",
"0.59087026",
"0.58901316",
"0.5858419",
"0.58... | 0.0 | -1 |
Callback that gets called for any event on the EDR event bus | def on_bus_message(self, channel, method_frame, header_frame, body):
try:
# there are two messages that get broadcast that we really
# don"t care about. They have to do with feed synchronization
# and other internal book-keeping
if method_frame.routing_key in self.capture_events:
event = {
"content_type": header_frame.content_type,
"routing_key": method_frame.routing_key,
"body": body
}
self.logger.debug("Received Message: %s - %s" % (header_frame.content_type, method_frame.routing_key))
self.processor_pool.apply_async(process_event, (self.event_processor, event))
else:
self.logger.debug("Unknown message info: %s" % method_frame.routing_key)
except:
self.logger.exception("Error processing bus message") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def event_in_cb(self, msg):\n self.event = msg.data",
"def process_event(self, event):\r\n pass",
"def visit_event(self, event):",
"def handleEvents(self, events):\n pass",
"def on_event(self, event):\n pass",
"def on_event(self, event):\r\n pass",
"def event_receive(... | [
"0.6813228",
"0.67946595",
"0.6717539",
"0.6711378",
"0.6636821",
"0.6603972",
"0.6455036",
"0.6390352",
"0.63873655",
"0.6378598",
"0.6359191",
"0.63422745",
"0.6334636",
"0.6332409",
"0.6296997",
"0.6277028",
"0.627466",
"0.62578577",
"0.62556595",
"0.6215644",
"0.61823285"... | 0.0 | -1 |
Retrieve which events to capture from the config | def set_capture_events_from_config(self):
event_config = [
{
"config_key": "events_watchlist",
"events": [
"watchlist.hit.process",
"watchlist.hit.binary",
"watchlist.storage.hit.process",
"watchlist.storage.hit.binary"
],
"options": self.forwarder_options.get("wlhitnotifenabled", "0")
},
{
"config_key": "events_feed",
"events": [
"feed.ingress.hit.process",
"feed.ingress.hit.binary",
"feed.ingress.hit.host",
"feed.storage.hit.process",
"feed.storage.hit.binary",
"feed.query.hit.process",
"feed.query.hit.binary"
],
"options": self.forwarder_options.get("feedhitnotif", "0")
},
{
"config_key": "events_alert",
"events": [
"alert.watchlist.hit.ingress.process",
"alert.watchlist.hit.ingress.binary",
"alert.watchlist.hit.ingress.host",
"alert.watchlist.hit.query.process",
"alert.watchlist.hit.query.binary"
],
"options": self.forwarder_options.get("alertnotifenabled", "0")
},
{
"config_key": "events_raw_sensor",
"events": [
"ingress.event.process",
"ingress.event.procstart",
"ingress.event.netconn",
"ingress.event.procend",
"ingress.event.childproc",
"ingress.event.moduleload",
"ingress.event.module",
"ingress.event.filemod",
"ingress.event.regmod"
"ingress.event.tamper",
"ingress.event.crossprocopen",
"ingress.event.remotethread",
"ingress.event.processblock",
"ingress.event.emetmitigation",
],
"options": self.forwarder_options.get("rawsensnotifenabled", "0")
},
{
"config_key": "events_binary_observed",
"events": ["binaryinfo.host.observed",
"binaryinfo.observed,"
"binaryinfo.group.observed"],
"options": self.forwarder_options.get("binobsnotifenabled", "0")
},
{
"config_key": "events_binary_upload",
"events": ["binarystore.file.added"],
"options": self.forwarder_options.get("binuplnotifenabled", "0")
}
]
self.capture_events = []
for event_type in event_config:
events = self.forwarder_options.get(event_type["config_key"], "0").lower()
if events == "all":
self.capture_events.extend(event_type["events"])
elif events != "0":
events_from_config = events.split(",")
events_to_capture = list(set(events_from_config) & set(event_type["events"]))
self.capture_events.extend(events_to_capture)
self.logger.info("Configured to capture events: %s" % self.capture_events) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_events(self):\n #Returne the capture events\n raise NotImplementedError",
"def get_events(self):\n #Returne the capture events\n raise NotImplementedError",
"def get_events(self):\n raise NotImplementedError",
"def get_events(self):\n raise NotImplementedErro... | [
"0.7154731",
"0.7154731",
"0.6736886",
"0.6736886",
"0.6634429",
"0.6563874",
"0.6368687",
"0.6339225",
"0.6153467",
"0.6147387",
"0.6090058",
"0.60785455",
"0.6055919",
"0.6055919",
"0.6025618",
"0.60202944",
"0.60145056",
"0.60046005",
"0.59880394",
"0.5945153",
"0.5929929"... | 0.7547521 | 0 |
the id of the Condition | def __init__(self):
self.id = None
self.typeInfo['id'] = 'string'
"""the owner of the Condition."""
self.account = None
self.typeInfo['account'] = 'string'
"""Details of the Counter."""
self.counter = None
self.typeInfo['counter'] = 'list'
"""the domain name of the owner."""
self.domain = None
self.typeInfo['domain'] = 'string'
"""the domain id of the Condition owner"""
self.domainid = None
self.typeInfo['domainid'] = 'string'
"""the project name of the Condition"""
self.project = None
self.typeInfo['project'] = 'string'
"""the project id of the Condition."""
self.projectid = None
self.typeInfo['projectid'] = 'string'
"""Relational Operator to be used with threshold."""
self.relationaloperator = None
self.typeInfo['relationaloperator'] = 'string'
"""Threshold Value for the counter."""
self.threshold = None
self.typeInfo['threshold'] = 'long'
"""zone id of counter"""
self.zoneid = None
self.typeInfo['zoneid'] = 'string' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getId(self):",
"def condition_id(self, condition_id):\n\n self._condition_id = condition_id",
"def id(self):\n return self.status.id",
"def getID():",
"def _id(self):\n pass",
"def get_id(self):\n return \"required_modules_exists_but_condition_is_false_plugin\"",
"def ch... | [
"0.615068",
"0.60920733",
"0.60874665",
"0.60557884",
"0.5979219",
"0.5969927",
"0.5945815",
"0.593884",
"0.59332013",
"0.589888",
"0.5893271",
"0.58621705",
"0.58531296",
"0.58531296",
"0.58335763",
"0.57970726",
"0.57366246",
"0.57366246",
"0.57366246",
"0.57366246",
"0.571... | 0.0 | -1 |
Constructs a request and sends it to the endpoint to create a custom job instance. | def Create(self,
parent,
specs=None,
config_path=None,
display_name=None,
python_package_uri=None,
args=None,
command=None,
kms_key_name=None,
network=None,
service_account=None):
if not python_package_uri:
python_package_uri = []
job_spec = self.messages.GoogleCloudAiplatformV1beta1CustomJobSpec()
job_spec.network = network
job_spec.serviceAccount = service_account
if config_path:
data = yaml.load_path(config_path)
if data:
job_spec = messages_util.DictToMessageWithErrorCheck(
data, self.messages.GoogleCloudAiplatformV1beta1CustomJobSpec)
worker_pool_specs = []
if specs is not None:
for spec in specs:
machine_type = spec.get('machine-type')
if not spec.get('replica-count'):
replica_count = 1
else:
replica_count = int(spec.get('replica-count'))
container_image_uri = spec.get('container-image-uri')
python_image_uri = spec.get('python-image-uri')
python_module = spec.get('python-module')
machine_spec = (
self.messages.GoogleCloudAiplatformV1beta1MachineSpec(
machineType=machine_type))
worker_pool_spec = (
self.messages.GoogleCloudAiplatformV1beta1WorkerPoolSpec(
replicaCount=replica_count, machineSpec=machine_spec))
if container_image_uri:
worker_pool_spec.containerSpec = (
self.messages.GoogleCloudAiplatformV1beta1ContainerSpec(
imageUri=container_image_uri))
if args is not None:
worker_pool_spec.containerSpec.args = args
if command is not None:
worker_pool_spec.containerSpec.command = command
if python_package_uri or python_image_uri or python_module:
worker_pool_spec.pythonPackageSpec = (
self.messages.GoogleCloudAiplatformV1beta1PythonPackageSpec(
executorImageUri=python_image_uri,
packageUris=python_package_uri,
pythonModule=python_module))
if args is not None:
worker_pool_spec.pythonPackageSpec.args = args
worker_pool_specs.append(worker_pool_spec)
if worker_pool_specs:
job_spec.workerPoolSpecs = worker_pool_specs
validation.ValidateWorkerPoolSpec(job_spec.workerPoolSpecs)
custom_job = (
self.messages.GoogleCloudAiplatformV1beta1CustomJob(
displayName=display_name,
jobSpec=job_spec))
if kms_key_name is not None:
custom_job.encryptionSpec = self.messages.GoogleCloudAiplatformV1beta1EncryptionSpec(
kmsKeyName=kms_key_name)
return self._service.Create(
self.messages.AiplatformProjectsLocationsCustomJobsCreateRequest(
parent=parent, googleCloudAiplatformV1beta1CustomJob=custom_job)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request_factory(self) -> 'JSONRPCRequest':\n return JSONRPCRequest()",
"def post(self):\n data, errors = JobSchema().loads(request.data)\n\n if errors:\n return Response().send(\n data=None, status=400, code=\"bad_request\", message=errors\n )\n ... | [
"0.65077955",
"0.6448152",
"0.64046395",
"0.63458514",
"0.6320473",
"0.63068354",
"0.628952",
"0.62621844",
"0.6166124",
"0.61317235",
"0.61317235",
"0.61317235",
"0.61317235",
"0.61317235",
"0.61317235",
"0.61317235",
"0.61317235",
"0.61317235",
"0.61317235",
"0.61317235",
"... | 0.0 | -1 |
Returns a function to decide if log fetcher should continue polling. | def CheckJobComplete(self, name):
request = self.messages.AiplatformProjectsLocationsCustomJobsGetRequest(
name=name)
response = self._service.Get(request)
def ShouldContinue(periods_without_logs):
if periods_without_logs <= 1:
return True
return response.endTime is None
return ShouldContinue | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _do_request(self):\n\n if time.time() < self._next_request:\n return False\n else:\n return True",
"def should_poll(self):\n return True",
"def should_poll(self):\n return True",
"def should_poll(self):\n return True",
"def should_poll(self):\n ... | [
"0.6179781",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.6099804",
"0.60813695",
"0.6056094",
"0.6056094",
"0.6056094",
"0.6056094",
... | 0.0 | -1 |
Implementation of TPMINVNOM00000 Step 1.1 | def upload(version=minv.__version__, release="1"):
version = version or minv.__version__
put(
join(
env.builder_path,
"build/RPMS/minv-%s-%s.noarch.rpm" % (version, release)
), ""
)
put("minv/package/minv_install_postgresql.sh", "")
sudo("chmod a+x minv_install_postgresql.sh")
with lcd(env.ink_path):
for rpm in RPMS:
put(rpm, "") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTru(n,int_method,func) :\n m = np.asarray([0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10])\n bes = np.asarray([-0.5,0,0.43675,0.47773,0.49231,0.49316,0.49280,0.50325,\n 0.51140,0.52169,0.55823,0.58086,0.60463,0.61483,0.66995])\n p = np.asarray([1,0,0.61007,0.77491,0.84071,0.87... | [
"0.5948996",
"0.5655197",
"0.5646285",
"0.5632018",
"0.5629894",
"0.5600689",
"0.55927324",
"0.54705757",
"0.54594123",
"0.5431765",
"0.5404841",
"0.5401604",
"0.5367439",
"0.53368443",
"0.5317328",
"0.53077716",
"0.52990746",
"0.52621627",
"0.52585423",
"0.52466846",
"0.5245... | 0.0 | -1 |
Implementation of TPMINVNOM00000 Step 1.2 | def install(version=minv.__version__, release="1"):
sudo("yum install -y %s" % " ".join(RPMS))
sudo("yum install -y minv-%s-%s.noarch.rpm" % (version, release))
sudo(
'printf "abcdefghijklmnopq\nabcdefghijklmnopq" '
'| sh minv_install_postgresql.sh --tablespace /disk/minv_tablespace/'
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTru(n,int_method,func) :\n m = np.asarray([0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10])\n bes = np.asarray([-0.5,0,0.43675,0.47773,0.49231,0.49316,0.49280,0.50325,\n 0.51140,0.52169,0.55823,0.58086,0.60463,0.61483,0.66995])\n p = np.asarray([1,0,0.61007,0.77491,0.84071,0.87... | [
"0.59679216",
"0.5714044",
"0.5704294",
"0.5693948",
"0.56368655",
"0.5636519",
"0.558531",
"0.55831385",
"0.5476309",
"0.545802",
"0.54322004",
"0.541791",
"0.5415495",
"0.5400221",
"0.53617483",
"0.5336507",
"0.5317923",
"0.52990615",
"0.529753",
"0.5280693",
"0.52662027",
... | 0.0 | -1 |
Implementation of TPMINVNOM00000 Step 1.3 | def config():
sudo(
r"sed -i '/#password=/c\password=abcdefghijklmnopq' /etc/minv/minv.conf"
)
sudo(
r"sed -i '/log_level = INFO/c\log_level = DEBUG' /etc/minv/minv.conf"
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTru(n,int_method,func) :\n m = np.asarray([0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10])\n bes = np.asarray([-0.5,0,0.43675,0.47773,0.49231,0.49316,0.49280,0.50325,\n 0.51140,0.52169,0.55823,0.58086,0.60463,0.61483,0.66995])\n p = np.asarray([1,0,0.61007,0.77491,0.84071,0.87... | [
"0.6024059",
"0.58742326",
"0.5747745",
"0.57027227",
"0.5643047",
"0.5618062",
"0.5584847",
"0.5547953",
"0.5515293",
"0.54348683",
"0.5426006",
"0.5425438",
"0.5389946",
"0.53414834",
"0.532526",
"0.5292617",
"0.52875394",
"0.5270108",
"0.52518106",
"0.5248011",
"0.52446",
... | 0.0 | -1 |
Implementation of TPMINVNOM00000 Step 1.4 | def setup():
sudo("minv_setup.sh") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTru(n,int_method,func) :\n m = np.asarray([0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10])\n bes = np.asarray([-0.5,0,0.43675,0.47773,0.49231,0.49316,0.49280,0.50325,\n 0.51140,0.52169,0.55823,0.58086,0.60463,0.61483,0.66995])\n p = np.asarray([1,0,0.61007,0.77491,0.84071,0.87... | [
"0.5975354",
"0.574612",
"0.57286537",
"0.5664337",
"0.5646467",
"0.5617162",
"0.55988216",
"0.55463326",
"0.5473999",
"0.5429033",
"0.54245466",
"0.54071516",
"0.5387508",
"0.5321748",
"0.5301005",
"0.5291172",
"0.52895296",
"0.5283824",
"0.52834505",
"0.52806515",
"0.527926... | 0.0 | -1 |
Implementation of TPMINVNOM00000 Step 1.5 | def run_services():
for service in ("minvd", "httpd", "ntpd"):
sudo("service %s start" % service)
sudo("chkconfig %s on" % service) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTru(n,int_method,func) :\n m = np.asarray([0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10])\n bes = np.asarray([-0.5,0,0.43675,0.47773,0.49231,0.49316,0.49280,0.50325,\n 0.51140,0.52169,0.55823,0.58086,0.60463,0.61483,0.66995])\n p = np.asarray([1,0,0.61007,0.77491,0.84071,0.87... | [
"0.60359097",
"0.57987505",
"0.57006055",
"0.56011873",
"0.55925214",
"0.5585051",
"0.55665624",
"0.55553573",
"0.55482876",
"0.5474939",
"0.5453688",
"0.5451362",
"0.5410539",
"0.540798",
"0.54051346",
"0.53952694",
"0.5374782",
"0.5306764",
"0.529368",
"0.5291805",
"0.52669... | 0.0 | -1 |
Implementation of TPMINVNOM00001 Steps 2 4 | def initialize():
with settings(prompts={'Password: ': 'test', 'Password (again): ': 'test'}):
for user, group in USER_GROUPS:
sudo("useradd %s -G %s,minv -g minv -N || true" % (user, group))
sudo("chmod g+rwx /home/%s" % user)
sudo('minv_ createuser %s -g %s' % (user, group), user="minv")
# upload script to create collections
put(
join(env.testdata_path, "scripts/initial_collections.sh"),
"", mode=0755
)
sudo("cp initial_collections.sh /home/minv-app-administrator/")
# upload collection configs
for conf in glob(join(env.testdata_path, "configurations/*.conf")):
put(conf, "", mode=0444, use_sudo=True)
sudo("cp %s /home/minv-app-administrator/" % basename(conf))
with cd("/home/minv-app-administrator/"):
sudo("chmod a+rx . *")
sudo(
"sh -l ./initial_collections.sh",
user="minv-app-administrator"
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTru(n,int_method,func) :\n m = np.asarray([0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10])\n bes = np.asarray([-0.5,0,0.43675,0.47773,0.49231,0.49316,0.49280,0.50325,\n 0.51140,0.52169,0.55823,0.58086,0.60463,0.61483,0.66995])\n p = np.asarray([1,0,0.61007,0.77491,0.84071,0.87... | [
"0.5861715",
"0.5764415",
"0.5698264",
"0.568726",
"0.56142557",
"0.55775875",
"0.54205596",
"0.54187477",
"0.54100156",
"0.5328907",
"0.529744",
"0.52744836",
"0.5273768",
"0.526851",
"0.5267105",
"0.52515525",
"0.52438647",
"0.5238269",
"0.5230068",
"0.5224255",
"0.52228403... | 0.0 | -1 |
Compares an image to its reference | def compare(self, reference, image):
if not os.path.isfile(reference):
raise PictureComparatorError("Reference file %s does not exist" % reference)
if not os.path.isfile(image):
raise PictureComparatorError("Image file %s does not exist" % image)
reference_img = cv2.imread(reference, 0)
image_img = cv2.imread(image, 0)
reference_width, reference_height = reference_img.shape[::-1]
image_width, image_height = image_img.shape[::-1]
if reference_width < image_width or reference_height < image_height:
raise PictureComparatorError("Reference picture must be greater than image to find")
method = cv2.TM_CCOEFF_NORMED
# Apply template Matching
res = cv2.matchTemplate(reference_img, image_img, method)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
if max_val > 0.95:
return Rectangle(max_loc[0], max_loc[1], image_width, image_height)
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compareTo(self,imagefullpath):\n exc = ExtractColor2(self.k)\n bgrcolor = exc.getColorBGR(imagefullpath)\n\n score = 0\n for i in range(self.k):\n score += np.linalg.norm(bgrcolor[i] - self._ref_BGRcolor[i])/(np.sqrt(255*255*3))\n score /= self.k\n return 1 ... | [
"0.7269888",
"0.69743997",
"0.6905206",
"0.6846669",
"0.67375135",
"0.6730658",
"0.67301905",
"0.67132235",
"0.6670823",
"0.66276044",
"0.65917426",
"0.6564198",
"0.65512747",
"0.6517447",
"0.65027654",
"0.6423081",
"0.64036614",
"0.63828444",
"0.6322787",
"0.6311486",
"0.628... | 0.7576849 | 0 |
From a matrix of difference pixels (for each pixel, we have 0 if pixel is the same, or nonzero if they are different), creates list of pixels which are different a PNG image of the same size as 'step' image, where each different pixel is coloured RED | def _build_list_of_changed_pixels(self, diff, image_width, image_height, min_width, min_height, exclude_zones):
# complete diff "image" to the size of step image
diff = numpy.pad(diff, ((0, max(0, image_height - min_height)), (0, max(0, image_width - min_width))), constant_values=1)
# ignore excluded pixels
diff *= self._build_list_of_excluded_pixels2(exclude_zones, image_width, image_height)
# draw mask of differences
mask = numpy.ones((image_height, image_width, 1), dtype=uint8)
diff_image = numpy.zeros((image_height, image_width, 4), dtype=uint8)
cnd = diff[:,:] > 0 # says which pixels are non-zeros
diff_image[cnd] = mask[cnd]
diff_image *= numpy.array([0, 0, 255, 255], dtype=uint8) # print red pixels
diff_pixels = numpy.transpose(diff.nonzero());
return diff_pixels, diff_image | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def separate_colors(self):\n colors = self.get_sorted_pixels()\n colors_dict = dict((val[1], Image.new('RGB', self.size, (255,255,255))) \n for val in colors)\n pixel_dict = dict((img, []) for img in colors_dict.keys())\n\n pix = self.image.load()\n for... | [
"0.594339",
"0.5888286",
"0.5828619",
"0.5812646",
"0.5808996",
"0.5784285",
"0.57349354",
"0.57313955",
"0.5709643",
"0.56814396",
"0.566322",
"0.56176597",
"0.55183667",
"0.5507987",
"0.54847234",
"0.54687953",
"0.5410043",
"0.53843975",
"0.53818494",
"0.53818494",
"0.53743... | 0.7071252 | 0 |
From the list of rectangles, build a list of pixels that these rectangles cover | def _build_list_of_excluded_pixels2(self, exclude_zones, img_width, img_height):
full_image = numpy.ones((img_height, img_width), dtype=uint8)
for x, y, width, height in exclude_zones:
# creates a matrix where 0 is placed on pixels to exclude, and 1 on pixel to keep
exclusion = numpy.zeros((height, width), dtype=uint8)
exclusion = numpy.pad(exclusion, ((min(y, img_height) , max(0, img_height - (y + height))), (min(x, img_width), max(0, img_width - (x + width)))), constant_values=1)
full_image *= exclusion[0:img_height, 0:img_width] # crop exclusion array if it's size is higher than image (exclusion zone outside of image dimensions)
return full_image | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rect(rows: int, cols: int, top: int = 0,\n left: int = 0) -> List['GridQubit']:\n return [\n GridQubit(row, col)\n for row in range(top, top + rows)\n for col in range(left, left + cols)\n ]",
"def find_rects(image: np.ndarray) -> List[np.ndarray]:\n... | [
"0.6603085",
"0.65592986",
"0.65554035",
"0.6548141",
"0.65277016",
"0.6455441",
"0.6452907",
"0.644425",
"0.64078",
"0.6345731",
"0.63407683",
"0.63396865",
"0.6298158",
"0.62660736",
"0.6236707",
"0.6198757",
"0.61927736",
"0.6180278",
"0.616941",
"0.61400336",
"0.61380047"... | 0.59542006 | 37 |
From the list of rectangles, build a list of pixels that these rectangles cover | def _build_list_of_excluded_pixels(self, exclude_zones):
pixels = []
for x, y, width, height in exclude_zones:
for row in range(height):
for col in range(width):
pixels.append(Pixel(col + x, row + y))
return pixels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rect(rows: int, cols: int, top: int = 0,\n left: int = 0) -> List['GridQubit']:\n return [\n GridQubit(row, col)\n for row in range(top, top + rows)\n for col in range(left, left + cols)\n ]",
"def find_rects(image: np.ndarray) -> List[np.ndarray]:\n... | [
"0.66037875",
"0.6559397",
"0.6555009",
"0.65479845",
"0.6528629",
"0.6455227",
"0.6453855",
"0.64455384",
"0.64104044",
"0.6346816",
"0.63399655",
"0.6339705",
"0.62987906",
"0.6266192",
"0.6236844",
"0.61997765",
"0.6193706",
"0.6171467",
"0.6139797",
"0.6138508",
"0.612909... | 0.6178429 | 17 |
Check if two things have the same type. | def same_type(one, two):
return isinstance(one, type(two)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_equal_same_type(self, other):\n return True",
"def is_same(type1, type2):\n nake_type1 = remove_declarated(type1)\n nake_type2 = remove_declarated(type2)\n return nake_type1 == nake_type2",
"def sametype(variable1, variable2):\n\n # Return the result\n return isinstance(variable1,... | [
"0.826196",
"0.7960103",
"0.7685877",
"0.75767535",
"0.73899287",
"0.7386229",
"0.73627245",
"0.72946095",
"0.7151994",
"0.7137583",
"0.7062871",
"0.7059909",
"0.70217156",
"0.69869566",
"0.6975931",
"0.69511235",
"0.6951103",
"0.682518",
"0.6799043",
"0.6766386",
"0.67605907... | 0.8348503 | 0 |
Merge data from another configuration space into this one. | def merge(one, two, overwrite=False, typecheck=True):
if one is two:
return
if typecheck and not same_type(one, two):
raise ValueError('Type mismatch')
for (key, value) in two.items():
if key not in one:
one[key] = value
if typecheck and not same_type(one[key], value):
raise ValueError('Type mismatch')
if isinstance(value, dict):
merge(one[key], two[key], overwrite, typecheck)
elif not overwrite:
continue
else:
one[key] = two[key] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(self, other_config):\n # Make a copy of the current attributes in the config object.\n config_options = copy.copy(self._user_provided_options)\n\n # Merge in the user provided options from the other config\n config_options.update(other_config._user_provided_options)\n\n ... | [
"0.68907833",
"0.67463917",
"0.6724158",
"0.6697968",
"0.6695578",
"0.66716415",
"0.635137",
"0.6323535",
"0.6313957",
"0.628166",
"0.62575287",
"0.62176895",
"0.6143152",
"0.611059",
"0.61058307",
"0.6072944",
"0.60497296",
"0.5980816",
"0.59184533",
"0.5873966",
"0.5863279"... | 0.0 | -1 |
AirInstance constructor name The name of the instance input An object with the YAML description of the IR instance transmit_handler A function to be called to transmit pkts Add support to allow the specification of the MetaIR instance | def __init__(self, name, input, transmit_handler):
local_dir = os.path.dirname(os.path.abspath(__file__))
MetaIRInstance.__init__(self, os.path.join(local_dir, 'air_meta.yml'))
self.transmit_handler = transmit_handler
self.name = name
self.tm_started = False
self.disabled = True
# Add the content to the MetaIR instance
self.add_content(input)
self.port_count = self.meta_ir_object_map["layout"]["port_count"]
# Create the AIR objects: parsers, actinos, tables, pipelines and TMs
self.air_value_set = {}
self.air_value_map = {}
self.air_parser = {}
self.air_action = {}
self.air_table = {}
self.air_pipeline = {}
self.air_traffic_manager = {}
self.processors = {}
self.transmit_processor = TransmitProcessor(transmit_handler)
for name, val in self.value_set.items():
self.air_value_set[name] = [] # Just use a list
for name, val in self.value_map.items():
self.air_value_map[name] = {} # Just use a dict
for name, val in self.parser.items():
self.air_parser[name] = Parser(name, val, self.parse_state,
self.header, self.value_set)
self.processors[name] = self.air_parser[name]
for name, val in self.action.items():
self.air_action[name] = Action(name, val)
for name, val in self.table.items():
self.air_table[name] = Table(name, val, self.air_action)
for name, val in self.control_flow.items():
self.air_pipeline[name] = Pipeline(name, val, self.air_table,
self.air_action)
self.processors[name] = self.air_pipeline[name]
for name, val in self.traffic_manager.items():
self.air_traffic_manager[name] = SimpleQueueManager(name, val,
self.port_count)
self.processors[name] = self.air_traffic_manager[name]
# Plumb the layout
layout = self.meta_ir_object_map["layout"]
meta_ir_assert(layout["format"] == "list", "Unsupported layout: not a list")
layout_name_list = layout["implementation"]
meta_ir_assert(isinstance(layout_name_list, list),
"Layout implementation is not a list")
proc_count = len(layout_name_list)
for idx, processor_name in enumerate(layout_name_list):
cur_proc = self.processors[processor_name]
if idx == 0:
logging.debug("Layout: First processor %s" % cur_proc.name)
self.first_processor = cur_proc
if idx < proc_count - 1:
next_proc = self.processors[layout_name_list[idx + 1]]
cur_proc.next_processor = next_proc
else: # Last one connects to transmit processor
cur_proc.next_processor = self.transmit_processor
logging.debug("Layout %s to %s" % (cur_proc.name,
cur_proc.next_processor.name))
# Grab table initialization object if present
self.table_initialization = {}
ext_objs = self.external_object_map
if "table_initialization" in ext_objs.keys():
self.table_initialization = ext_objs["table_initialization"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None,\n add_on: Optional[pulumi.Input[pulumi.InputType['InstanceAddOnArgs']]] = None,\n availability_zone: Optional[pulumi.Input[str]] = None,\n bl... | [
"0.66051346",
"0.6576527",
"0.6427389",
"0.63597023",
"0.62879163",
"0.6271562",
"0.6235065",
"0.6202321",
"0.6141576",
"0.6116739",
"0.6116739",
"0.6116739",
"0.6116739",
"0.6116739",
"0.6116739",
"0.61087185",
"0.60978323",
"0.6088997",
"0.60772216",
"0.606114",
"0.6051864"... | 0.7563762 | 0 |
Process any table initialization spec from the IR desc The IR specification may provide a set of table initialization operations in a "table_initialization" object. This takes the form of a sequence of table entry specifications. | def process_table_init(self):
logging.debug("Processing table initialization, %d entries",
len(self.table_initialization))
for init_entry in self.table_initialization:
for table_name, entry_desc in init_entry.items():
self.air_table[table_name].add_entry(
table_entry.description_to_entry(entry_desc)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_up_tables(self):\n tables = []\n tables.append({'groupname': 'metadata',\n 'tablename': 'sim_info',\n 'description': desc.SimInfoRow,\n 'tabletitle': 'Simulation Information'})\n tables.append({'groupname': 'metadata',\n... | [
"0.52702624",
"0.51661",
"0.51060444",
"0.5094332",
"0.50876445",
"0.50695586",
"0.50232565",
"0.49792466",
"0.49553454",
"0.49386698",
"0.49274278",
"0.49077904",
"0.4889465",
"0.48876804",
"0.48618603",
"0.48576298",
"0.48565733",
"0.48539078",
"0.4839813",
"0.48349887",
"0... | 0.7456325 | 0 |
Enable the switch instance Start the traffic manager threads and allow packets to enter the processor chain | def enable(self):
if not self.tm_started:
for name, tm in self.air_traffic_manager.items():
logging.debug("Starting tm %s" % name)
tm.start()
tm_started = True
logging.debug("Enabling switch %s" % self.name)
self.disabled = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enable(self):\n self.switch.enable()\n self._enabled = True",
"def start_sending_to_switch(self):\n self.switch_active = True\n for message in self.internal_switch_buffer:\n self.switch.buffer.append(message)\n self.internal_switch_buffer = []",
"def launch ():... | [
"0.633651",
"0.63337624",
"0.627072",
"0.62615603",
"0.6093382",
"0.6046594",
"0.595381",
"0.5936305",
"0.58609205",
"0.58298725",
"0.5779756",
"0.57681865",
"0.5766365",
"0.5766356",
"0.5763502",
"0.57629",
"0.57612556",
"0.5747415",
"0.5741657",
"0.57210463",
"0.5721009",
... | 0.7502978 | 0 |
Disable the switch instance Packets on ingress are discarded while the switch is disabled. Traffic manager threads are not stopped. | def disable(self):
logging.debug("Disabling switch %s" % self.name)
self.disabled = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def async_turn_off(self):\n path = \"/ip/firewall/nat\"\n param = \".id\"\n value = None\n for uid in self._ctrl.data[\"nat\"]:\n if (\n self._ctrl.data[\"nat\"][uid][\"name\"]\n == f\"{self._data['protocol']}:{self._data['dst-port']}\"\n ... | [
"0.66462976",
"0.6192181",
"0.6160286",
"0.6113852",
"0.6101358",
"0.6030463",
"0.6019299",
"0.60160685",
"0.6007818",
"0.59888124",
"0.5958932",
"0.59445566",
"0.5917474",
"0.591579",
"0.5867535",
"0.5856679",
"0.5840998",
"0.583786",
"0.58215153",
"0.57709235",
"0.5764594",... | 0.70145595 | 0 |
in_port The ingress port number on which packet arrived packet A bytearray with the packet data | def process_packet(self, in_port, packet):
buf = bytearray(packet)
for idx in range((len(packet) + 19)/20):
logging.debug(hexify(buf[20*idx : 20*(idx+1)], 20))
if self.disabled:
logging.debug("Switch is disabled; discarding packet")
return
parsed_packet = ParsedPacket(buf, self.metadata)
logging.debug("Processing packet %d from port %d with %s" %
(parsed_packet.id, in_port,
self.first_processor.name))
self.first_processor.process(parsed_packet) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def port_in(self, port_in):\n\n self._port_in = port_in",
"def port_in(self, port_in):\n\n self._port_in = port_in",
"def _packet_in_debug(self, ev, in_port):\n #*** Extract parameters:\n msg = ev.msg\n datapath = msg.datapath\n dpid = datapath.id\n pkt = packet... | [
"0.6083645",
"0.6083645",
"0.6004842",
"0.5940256",
"0.58412826",
"0.5745346",
"0.56811863",
"0.56805307",
"0.56792486",
"0.5678725",
"0.55001324",
"0.5463868",
"0.545723",
"0.54208636",
"0.5390863",
"0.5390862",
"0.537292",
"0.5355706",
"0.5340329",
"0.5338251",
"0.5322882",... | 0.5686567 | 6 |
Transmit handler template for documentation out_port The port number to which the packet is to be sent packet A bytearray object holding the packet to transmit | def dummy_transmit_handler(out_port, packet):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, out):",
"def _post(self, which_port, msg):\n return _spacegrant_swig.binary_sink_sptr__post(self, which_port, msg)",
"def send_traffic_data(serialport, pack):\n pack[0] = 0x01\n pack[1] = 0x00\n serialport.write(pack)\n logging.debug(\"Traffic Data - Sent.\")\n logging.deb... | [
"0.5656294",
"0.5640042",
"0.5389474",
"0.53658545",
"0.52940327",
"0.52939874",
"0.5285707",
"0.51725745",
"0.51605856",
"0.5146283",
"0.51232743",
"0.5088026",
"0.5069205",
"0.50586265",
"0.50550586",
"0.50533634",
"0.50321823",
"0.5028129",
"0.49887457",
"0.4957033",
"0.49... | 0.655866 | 0 |
Process interface that sends a packet parsed_packet The packet instance to transmit | def process(self, parsed_packet):
byte_buf = parsed_packet.serialize()
out_port= parsed_packet.get_field("intrinsic_metadata.egress_port")
logging.debug("Transmit pkt id %d to %d" % (parsed_packet.id, out_port))
buf = bytearray(byte_buf)
for idx in range((len(buf) + 19)/20):
logging.debug(hexify(buf[20*idx : 20*(idx+1)], 20))
self.transmit_handler(out_port, byte_buf) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self, packet):\n pass",
"def process(self, pkt):\n pass",
"def _do_some_logic(self, packet):\n\n\n pass",
"def process_packet(self, in_port, packet):\n \n buf = bytearray(packet)\n for idx in range((len(packet) + 19)/20):\n logging.debug(he... | [
"0.8039347",
"0.7425329",
"0.6986574",
"0.69667333",
"0.6850102",
"0.66773987",
"0.65571284",
"0.655704",
"0.65034556",
"0.64887303",
"0.64614993",
"0.64393044",
"0.6438453",
"0.6343893",
"0.633845",
"0.63383657",
"0.62919194",
"0.62790996",
"0.626932",
"0.6252799",
"0.625152... | 0.7235204 | 2 |
Send message to specified channel. | def sendmsg(msg, target=channel):
msg = bytes('PRIVMSG ' + target + ' :' + msg + '\n', 'UTF-8')
sleep(randint(5, 10) / 10) # to avoid throttling due to flooding
write(msg)
ircsocket.send(msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def send_message(self, channel : str, message : str):\n await self._connection.send_message(channel, message)",
"def sendMsg(self, channel, message, length=None):\n self.logger.info(\"Sending in %s: %s\" % (channel, message))\n self.msg(channel, message, length)",
"def send_message(s... | [
"0.82728493",
"0.7965429",
"0.7865041",
"0.77663475",
"0.7414901",
"0.7366934",
"0.7189363",
"0.71749264",
"0.7114904",
"0.7107324",
"0.7078955",
"0.703922",
"0.69624746",
"0.6917826",
"0.69085354",
"0.6878344",
"0.6788846",
"0.67383105",
"0.6678887",
"0.66784793",
"0.6666718... | 0.0 | -1 |
Respond to server Pings. | def ping(msg):
msg = msg[0:1] + 'O' + msg[2:]
ircsocket.send(bytes(msg, 'utf-8'))
sendmsg('This message should be eaten by irc. QQ.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ping_response():\n\n return Response(\"ok\", status=200)",
"def ping(self) -> Response:\n raise NotImplementedError",
"def ping():\n\treturn HTTPResponse(status=200)",
"def ping():\r\n return make_response(\"pong!\", 200)",
"def ping():\n return jsonify({'response': 'pong'}), 200",
"a... | [
"0.71649414",
"0.7104726",
"0.6999726",
"0.69393915",
"0.68687826",
"0.67558753",
"0.6743167",
"0.6712012",
"0.6712012",
"0.6712012",
"0.6712012",
"0.6609778",
"0.6493357",
"0.6481408",
"0.64656126",
"0.63697636",
"0.63491356",
"0.634054",
"0.6311246",
"0.62131786",
"0.620798... | 0.0 | -1 |
Wrapper around the MappingColumns class to create the list of suggested mappings | def build_column_mapping(raw_columns, dest_columns, previous_mapping=None, map_args=None,
default_mappings=None, thresh=0):
return MappingColumns(raw_columns, dest_columns, previous_mapping=previous_mapping,
map_args=map_args, default_mappings=default_mappings,
threshold=thresh).final_mappings | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_column_mapping_suggestions(request):\n body = json.loads(request.body)\n import_file = ImportFile.objects.get(pk=body.get('import_file_id'))\n org_id = body.get('org_id')\n result = {'status': 'success'}\n # Make a dictionary of the column names and their respective types.\n # Build this ... | [
"0.6701818",
"0.66194874",
"0.64661616",
"0.6289916",
"0.62860745",
"0.6266867",
"0.6198274",
"0.6167986",
"0.6022413",
"0.5931042",
"0.5810462",
"0.5776295",
"0.5758414",
"0.5749279",
"0.57203007",
"0.5662926",
"0.5634716",
"0.5623659",
"0.55996656",
"0.5535574",
"0.5528489"... | 0.63081527 | 3 |
Set any attributes that are passed in as initial data. | def apply_initial_data(model, initial_data):
for item in initial_data:
value = initial_data[item]
if hasattr(model, item):
setattr(model, item, value)
elif hasattr(model, 'extra_data') and isinstance(model.extra_data, dict):
model.extra_data[item] = value
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_attributes(self):",
"def __init__(self, **initial_attributes):\n\n for attribute_name, attribute_value in initial_attributes.items():\n setattr(self, attribute_name, attribute_value)",
"def init_attrs(self):\n raise NotImplementedError",
"def __init__(self, **attributes):\n ... | [
"0.79411536",
"0.7760498",
"0.74538267",
"0.73853767",
"0.7362866",
"0.71887094",
"0.7146371",
"0.7146371",
"0.7146371",
"0.7098289",
"0.70153654",
"0.699478",
"0.69330215",
"0.68741333",
"0.68410134",
"0.6835195",
"0.673314",
"0.67293113",
"0.66948265",
"0.6694178",
"0.66822... | 0.6589023 | 28 |
Concatenate the values into one string to set for target. | def _concat_values(concat_columns, column_values, delimiter):
# Use the order of values that we got from concat_columns def.
values = [
column_values[item] for item in concat_columns if item in column_values
]
return delimiter.join(values) or None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def concat(values, sep=', '):\n concat_str = None\n try:\n concat_str = sep.join([str(v) for v in values if not is_empty(v)])\n except Exception as e:\n pass\n return concat_str",
"def joined_parameter(*values: str) -> str:\n return \"+\".join(values)",
"def _concat(self, *args, **... | [
"0.66425836",
"0.64691097",
"0.63475597",
"0.6099031",
"0.60475785",
"0.60406435",
"0.604041",
"0.60189885",
"0.6017926",
"0.5998727",
"0.5937355",
"0.5918181",
"0.5915184",
"0.5901235",
"0.5898622",
"0.58785903",
"0.5799823",
"0.5796432",
"0.5734698",
"0.5730965",
"0.5715827... | 0.54848677 | 46 |
Set the column value as the target attr on our model. | def apply_column_value(raw_column_name, column_value, model, mapping, is_extra_data, cleaner):
# If the item is the extra_data column, then make sure to save it to the
# extra_data field of the database
if raw_column_name in mapping:
table_name, mapped_column_name, display_name, is_extra_data = mapping.get(raw_column_name)
# special postal case:
if mapped_column_name in ['postal_code', 'owner_postal_code']:
if '-' in str(column_value):
postal = str(column_value).split('-')[0].zfill(5)
ext = str(column_value).split('-')[1].zfill(4)
column_value = postal + '-' + ext
column_value = str(column_value).zfill(5)
cleaned_value = None
if cleaner:
# Get the list of Quantity fields from the Column object in SEED. This is non-ideal, since the
# rest of the mapping code does not use SEED models. Perhaps make this an argument.
if (model.__class__.__name__, mapped_column_name) in apps.get_model('seed',
'Column').QUANTITY_UNIT_COLUMNS:
# clean against the database type first
cleaned_value = cleaner.clean_value(column_value, mapped_column_name, is_extra_data)
# This is a temporary fix for when the raw_column_name and the mapped_column_name
# are the same. It causes the units to be cast twice since the cleaner look up finds
# the same column twice. The cleaner needs to be cleaned up quite a bit to handle
# this error correctly.
if mapped_column_name != raw_column_name:
# now clean against the raw name with pint (Quantity Units) because that's the column
# that holds the units needed to interpret the value correctly
cleaned_value = cleaner.clean_value(cleaned_value, raw_column_name,
is_extra_data)
else:
cleaned_value = cleaner.clean_value(column_value, mapped_column_name, is_extra_data)
else:
cleaned_value = default_cleaner(column_value)
if is_extra_data:
if hasattr(model, 'extra_data'):
# only save it if the model and the mapping are the same
if model.__class__.__name__ == table_name:
if isinstance(cleaned_value, (datetime, date)):
# TODO: create an encoder for datetime once we are in Django 1.11
model.extra_data[mapped_column_name] = cleaned_value.isoformat()
else:
model.extra_data[mapped_column_name] = cleaned_value
else:
# Simply set the field to the cleaned value if it is the correct model
if model.__class__.__name__ == table_name:
setattr(model, mapped_column_name, cleaned_value)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_attribute(self, name, value):\n attrs = self._column.attrs\n attrs[name] = value\n self._column.attrs = attrs",
"def __set__(self, instance, value):\r\n if instance:\r\n return instance._values[self.column.column_name].setval(value)\r\n else:\r\n r... | [
"0.7223488",
"0.69311714",
"0.6659743",
"0.65025675",
"0.64680314",
"0.64388746",
"0.64149034",
"0.63883615",
"0.6383518",
"0.63276327",
"0.6326977",
"0.6314786",
"0.62230754",
"0.62147987",
"0.61330974",
"0.6095479",
"0.6058556",
"0.6057366",
"0.6056918",
"0.6027524",
"0.602... | 0.0 | -1 |
Go through the list of dictionaries and setup their keys. | def _set_default_concat_config(concat):
concat = concat or []
if not isinstance(concat, list):
concat = [concat]
for c in concat:
c['target'] = c.get('target', '__broken_target__')
c['concat_columns'] = c.get('concat_columns', [])
c['delimiter'] = c.get('delimiter', ' ')
c['concat_values'] = {}
return concat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def example_dict_from_dict_list(dict_list,recursive=False):\n if not isinstance(dict_list,list):\n if isinstance(dict_list,dict):\n dict_list = [dict_list]\n else:\n raise TypeError(\"dict_list must be a dict or a list of dicts\")\n else:\n if not all([isinstance(x,... | [
"0.5770778",
"0.5673443",
"0.5617882",
"0.5580341",
"0.55801505",
"0.5575327",
"0.5571679",
"0.55587304",
"0.5528891",
"0.5508562",
"0.55064344",
"0.5500273",
"0.5479882",
"0.5471181",
"0.5468983",
"0.546297",
"0.54368216",
"0.54329467",
"0.5403189",
"0.5389576",
"0.5385095",... | 0.0 | -1 |
Fields that are expanded (typically tax lot id) are also in need of normalization to remove characters that prevent easy matching. This method will remove unwanted characters from the jurisdiction tax lot id. Here are some examples of what actual city taxlots can look like 13153123902 069180102923 14A612 123.4123 PANL1593005 0.000099 00012312 12123121212134567 12 0123 TT0612 | def _normalize_expanded_field(value):
value = value.strip()
value = re.sub(r'\s{2,}', ' ', value)
value = re.sub(r'/{2,}', '/', value)
value = re.sub(r'\\{2,}', '\\\\', value)
value = re.sub(r'-{2,}', '-', value)
value = re.sub(r'\*{2,}', '*', value)
value = re.sub(r'\.{2,}', '.', value)
value = value.upper()
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tidy_telephone(telephone):\n junk = ['none', 'none1', 'na', 'n/a', 'same', 'yes', 'cell', 'offsite']\n telephone = telephone.replace('xxx-xxx-xxxx', '')\n telephone = telephone.replace('ext', ' x')\n telephone = telephone.replace(' cell', '')\n telephone = telephone.replace('\"', '')\n teleph... | [
"0.617545",
"0.59764254",
"0.5974559",
"0.58157676",
"0.57999325",
"0.57070196",
"0.56774664",
"0.5623333",
"0.56135535",
"0.55448365",
"0.5531851",
"0.5499692",
"0.54500884",
"0.54454935",
"0.5440887",
"0.5432032",
"0.54141355",
"0.5411208",
"0.54100305",
"0.53966856",
"0.53... | 0.5550276 | 9 |
take a field from the csv and expand/split on a delimiter and return a list of individual values. If the return_list flag is set to true, then this method will return the data back as a list of new fields instead of a cleaned up string and normalized with semicolon delimiter | def expand_and_normalize_field(field, return_list=False):
if isinstance(field, basestring):
field = field.rstrip(';:,')
data = [_normalize_expanded_field(r) for r in re.split(",|;|:", field)]
if return_list:
return data
else:
return ";".join(data)
else:
if return_list:
return [field]
else:
return field | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def csv_line(value_parser):\n def convert(string):\n return list(map(value_parser, string.split(',')))\n return convert",
"def parse_and_flatten(df, field_name):\n\n # Parse and flatten the list\n lst = list(df[field_name])\n lst = [x.split('|') for x in lst]\n\n lst_flat = []\n for s... | [
"0.63519025",
"0.63037026",
"0.6226924",
"0.621855",
"0.621855",
"0.605141",
"0.60084903",
"0.5960452",
"0.5954665",
"0.58187693",
"0.58148223",
"0.57171553",
"0.56535655",
"0.5637533",
"0.56276727",
"0.55754817",
"0.55633485",
"0.55611026",
"0.54911935",
"0.54818034",
"0.543... | 0.7508108 | 0 |
Take a row and a field which may have delimited values and convert into a list of new rows with the same data expect for the replaced delimited value. | def expand_rows(row, delimited_fields, expand_row):
# _log.debug('expand_row is {}'.format(expand_row))
# go through the delimited fields and clean up the rows
copy_row = copy.deepcopy(row)
for d in delimited_fields:
if d in copy_row:
copy_row[d] = expand_and_normalize_field(copy_row[d], False)
if expand_row:
new_values = []
for d in delimited_fields:
fields = []
if d in copy_row:
for value in expand_and_normalize_field(copy_row[d], True):
fields.append({d: value})
new_values.append(fields)
# return all combinations of the lists
combinations = list(itertools.product(*new_values))
new_rows = []
for c in combinations:
new_row = copy.deepcopy(copy_row)
# c is a tuple because of the .product command
for item in c:
for k, v in item.items():
new_row[k] = v
new_rows.append(new_row)
return new_rows
else:
return [copy_row] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def processRow(self, row):\n\t\tif self.delim is not None:\n\t\t\trowArr = row.split(self.delim)\n\t\t\tmsg = \"row does not have expected number of columns found \" + str(len(rowArr)) + \" expected \" + str(self.rowSize)\n\t\t\tassert len(rowArr) == self.rowSize, msg\n\t\telse:\n\t\t\trowArr = row\n\t\t\t\n\t\tne... | [
"0.6390672",
"0.61461806",
"0.61275697",
"0.6075597",
"0.6021947",
"0.60119367",
"0.5930786",
"0.5849591",
"0.5666509",
"0.56609106",
"0.562658",
"0.56255656",
"0.5619078",
"0.5576439",
"0.55647933",
"0.55612415",
"0.5549309",
"0.5546282",
"0.5542975",
"0.5528512",
"0.5520903... | 0.63998896 | 0 |
Apply mapping of row data to model. | def map_row(row, mapping, model_class, extra_data_fields=[], cleaner=None, **kwargs):
initial_data = kwargs.get('initial_data', None)
model = model_class()
# _log.debug("map_row's mappings {}".format(mapping))
# If there are any initial states we need to set prior to mapping.
if initial_data:
model = apply_initial_data(model, initial_data)
# concat is not used as of 2016-09-14
# concat = _set_default_concat_config(concat)
for raw_field, value in row.items():
is_extra_data = True if raw_field in extra_data_fields else False
# Save the value if is is not None, keep empty fields.
if value is not None:
model = apply_column_value(raw_field, value, model, mapping, is_extra_data, cleaner)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def applyMapping(self):\n pass",
"def map(self, function=lambda item: item):\n for i, row in enumerate(self):\n for j, item in enumerate(row):\n row[j] = function(item)",
"def map_transfer_to_row(self, transfer):\n pass",
"def _do_mapping(self):\n pass",
... | [
"0.66845304",
"0.62534523",
"0.61838084",
"0.604524",
"0.59644157",
"0.5678246",
"0.56550837",
"0.5597702",
"0.5595955",
"0.5552257",
"0.55398905",
"0.54507",
"0.54413307",
"0.542242",
"0.54172045",
"0.54105145",
"0.5367758",
"0.5321824",
"0.5305091",
"0.5284699",
"0.52551997... | 0.77035165 | 0 |
Updates stats inside mod_stats_map with data gathered from the file. | def get_file_mod_stats_for_upstream_refs(file_name, mod_stats_map):
with open(file_name) as f:
lines = f.readlines()
upstream_ref = None
upstream_start_line = None
for line_number, line in enumerate(lines):
if REGION_START_TAG in line:
tag, ref_name = _extract_tag_and_ref_name_from_line(line, False)
if REGION_UPSTREAM_TAG in tag:
upstream_ref = ref_name
upstream_start_line = line_number
elif REGION_END_TAG in line and upstream_ref:
mod_stats = mod_stats_map[upstream_ref]
mod_stats.mod_count += 1
mod_stats.line_count += line_number - upstream_start_line - 1
upstream_ref = None
upstream_start_line = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_stat_file(self):\n logfile = \"../data/{}_stat.json\".format(self.ID)\n statobj = {\n 'hp': self.hp,\n 'max_hp': MAX_TANK_HP,\n 'ammo': self.ammo,\n 'score': self.score,\n 'age': self.age,\n 'alive': not self.is_dead(),\n ... | [
"0.63213795",
"0.61827755",
"0.57400024",
"0.5537577",
"0.5465735",
"0.5393763",
"0.5373763",
"0.5370881",
"0.53650606",
"0.5338288",
"0.5331641",
"0.52704084",
"0.52475107",
"0.5246663",
"0.51833093",
"0.5156864",
"0.51413554",
"0.51362735",
"0.5133316",
"0.51267594",
"0.512... | 0.63252497 | 0 |
Find the tracking file for the given file. Returns the last path mentioned in the file via a tracking tag or the equivalent thirdparty path given the file's path. If there is no file in the default path and no files mentioned within the file exist, returns None. Normally the thirdparty path must exist. Passing |check_exist|=False will bypass this check when it is not desired. An additional check is enabled by passing |check_uses_tag|=True. In this case the given file MUST use either a file track tag or another modification tag, before a tracking_path is returned. stats is a variable for keeping track of the status of the analyzer, which can be None. | def compute_tracking_path(stats, our_path, our_lines, do_lint_check=False,
check_exist=True, check_uses_tags=False):
tracking_path = staging.get_default_tracking_path(our_path)
base_matcher = re.compile(re.escape(FILE_TRACK_TAG) + r' "([^\"]+)"')
tag_matcher = re.compile(re.escape(REGION_START_TAG))
uses_any_tags = False
next_lineno = 1
for line in our_lines:
if stats:
stats['lineno'] = next_lineno
match = base_matcher.search(line)
if match:
tracking_path = match.group(1)
if not os.path.exists(tracking_path) and stats:
show_error(stats, 'Mod tracking path does not exist:\n' + line)
if next_lineno > MAX_ARC_TRACK_SEARCH_LINES:
show_error(stats, 'Tracking not allowed on line > %d' %
MAX_ARC_TRACK_SEARCH_LINES)
uses_any_tags = True
break
elif not uses_any_tags and tag_matcher.search(line):
uses_any_tags = True
next_lineno += 1
if (not do_lint_check and (uses_any_tags or not check_uses_tags) and
next_lineno > MAX_ARC_TRACK_SEARCH_LINES):
break
if not tracking_path:
return None
if check_uses_tags and not uses_any_tags:
return None
if check_exist and not os.path.exists(tracking_path):
return None
return tracking_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _findfile(self, path):\n\n # Build list of possible local file paths\n if not self._isurl(path):\n # Valid local paths\n filelist = self._possible_names(path)\n # Paths in self._destpath\n filelist += self._possible_names(self.abspath(path))\n el... | [
"0.54929686",
"0.5405405",
"0.5390188",
"0.538945",
"0.52806234",
"0.52451473",
"0.524215",
"0.5137974",
"0.5047577",
"0.502459",
"0.50199705",
"0.49906838",
"0.4970432",
"0.49497023",
"0.4910103",
"0.4907254",
"0.48910886",
"0.48726743",
"0.48697725",
"0.4835479",
"0.4827484... | 0.718714 | 0 |
Compute the notices object as if the two paths were properly staged. analyze_diffs needs to be independent of staging. Staging might not have been run, or might be out of date from when analyze_diffs is run. So we make a best attempt to reconstruct the notices that would have occurred poststaging. | def _compute_staged_notices(mods_path, third_party_path):
mods_notices = notices.Notices()
if mods_path:
mods_notices.add_sources([mods_path])
third_party_notices = notices.Notices()
if third_party_path:
third_party_notices.add_sources([third_party_path])
# If there are mods and third_party notices, pick the one that is more
# specific to the file, which is the one that has a deeper path.
if (_count_directory_levels_in_license_root(third_party_notices) >
_count_directory_levels_in_license_root(mods_notices)):
return third_party_notices
else:
return mods_notices | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_diffs(history):\n\n # First get all possible representations\n mgr = plugins_get_mgr() \n keys = mgr.search('representation')['representation']\n representations = [mgr.get_by_key('representation', k) for k in keys]\n\n for i in range(len(history)):\n if i+1 > len(history) - 1:\n ... | [
"0.5009308",
"0.50050104",
"0.47927547",
"0.47090858",
"0.4646092",
"0.46367276",
"0.4600246",
"0.45939845",
"0.4547362",
"0.45332745",
"0.45131713",
"0.45066488",
"0.44925582",
"0.44843617",
"0.44840214",
"0.4477567",
"0.4472213",
"0.44629148",
"0.4452782",
"0.4435036",
"0.4... | 0.5701247 | 0 |
Create a Vocabulary object. | def __init__(self, max_size=None, lower=True, unk_token=True, remove_stopwords=False, specials=('<pad>',)):
self._max_size = max_size
self._lower = lower
self._unk = unk_token
self.token2id = {token: i for i, token in enumerate(specials)}
self._id2token = list(specials)
self._token_count = Counter()
self.can_remove_stopwords=remove_stopwords
self.num_docs = 0
self.num_pos = 0
self.num_nnz = 0
self.corpus=None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vocab():\n symbols = DEFAULT_SPECIAL_SYMBOLS + [\"mouse\", \"dog\", \"tree\"]\n return Vocabulary(symbols)",
"def from_dict(cls, dikt: dict) -> 'Vocabulary':\n return util.deserialize_model(dikt, cls)",
"def create_vocab(vocab_path='ORBvoc-synth.txt'):\n total_time = 10 # seconds\n num_... | [
"0.67872804",
"0.660514",
"0.6490391",
"0.6246055",
"0.6192233",
"0.61789507",
"0.6158393",
"0.613217",
"0.61019224",
"0.60960674",
"0.606695",
"0.6037764",
"0.6025569",
"0.59994584",
"0.59994584",
"0.5967367",
"0.5922967",
"0.59061986",
"0.58743894",
"0.58231103",
"0.5815941... | 0.0 | -1 |
Add token to vocabulary. | def add_token(self, token):
token = self.process_token(token)
self._token_count.update([token]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_token(self,token):\n\t\tif not token:\n\t\t\tlogging.error(\"Token cannot be empty!\")\n\t\t\texit()\n\n\t\tself.tokens.append(token.lower())\n\t\t#self.user_defined_token = token.lower()",
"def add_embedding(self, token, embedding):\n self.word2idx[token] = self.vocab_size\n self.vocab_siz... | [
"0.7474371",
"0.7235822",
"0.6903988",
"0.6526929",
"0.65188766",
"0.6505907",
"0.6505907",
"0.64998305",
"0.6496983",
"0.6493279",
"0.64262176",
"0.6420701",
"0.6391367",
"0.6325264",
"0.63200015",
"0.62549394",
"0.62311953",
"0.622333",
"0.6177798",
"0.61690384",
"0.6133628... | 0.68879795 | 4 |
Update dictionary from a collection of documents. Each document is a list of tokens. | def add_documents(self, docs):
if 'sentences' in docs:
for sent in docs.sentences:
sent = map(self.process_token, [t for t in sent.tokens if not t.is_stopword])
self._token_count.update(sent)
else:
sent = list(map(self.process_token, [t for t in docs.tokens if not t.is_stopword]))
self._token_count.update(sent) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_documents(self, docs):\n for sent in docs:\n sent = map(self.process_token, sent)\n self._token_count.update(sent)",
"def add_document_lists(self, docs):\n for sent in docs:\n sent = map(self.process_token, sent)\n self._token_count.update(sent)",... | [
"0.68999934",
"0.6873283",
"0.6396484",
"0.6270356",
"0.6200283",
"0.61873966",
"0.61502284",
"0.6042249",
"0.6037067",
"0.5998114",
"0.59293014",
"0.58950543",
"0.5877849",
"0.5844076",
"0.58293545",
"0.5767847",
"0.57396615",
"0.5730059",
"0.5711739",
"0.563978",
"0.5620126... | 0.67038983 | 2 |
Update dictionary from a collection of documents. Each document is a list of tokens. | def add_document_lists(self, docs):
for sent in docs:
sent = map(self.process_token, sent)
self._token_count.update(sent) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_documents(self, docs):\n for sent in docs:\n sent = map(self.process_token, sent)\n self._token_count.update(sent)",
"def add_documents(self, docs):\n if 'sentences' in docs:\n for sent in docs.sentences:\n sent = map(self.process_token, [t fo... | [
"0.68998206",
"0.67045903",
"0.63965476",
"0.6270014",
"0.6202376",
"0.61885744",
"0.6151995",
"0.60434496",
"0.60377157",
"0.59981596",
"0.59295934",
"0.58968425",
"0.5878697",
"0.5846581",
"0.5829846",
"0.57702076",
"0.57415456",
"0.5731184",
"0.571159",
"0.56422395",
"0.56... | 0.6872754 | 1 |
Get the list of token_id given doc. | def doc2id(self, doc):
if isinstance(doc, string_types):
raise TypeError("doc2idx expects an array of unicode tokens on input, not a single string")
doc = map(self.process_token, doc)
return [self.token_to_id(token) for token in doc] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def doc2id(self, doc):\n doc = map(self.process_token, doc)\n return [self.token_to_id(token) for token in doc]",
"def get_tokens(self, document):\n raise NotImplementedError()",
"def doc2token(self, doc):\n return [self.word2idx[word] if self.word2idx.__contains__(word)\n ... | [
"0.71084183",
"0.6638949",
"0.64065033",
"0.6308615",
"0.6308615",
"0.6248695",
"0.6248695",
"0.616698",
"0.61223453",
"0.60448986",
"0.6016193",
"0.6015829",
"0.6009144",
"0.59384847",
"0.5869318",
"0.5861415",
"0.5859866",
"0.5852833",
"0.58410364",
"0.5834465",
"0.5816366"... | 0.6642477 | 1 |
Get the token list. | def id2doc(self, ids):
return [self.id_to_token(idx) for idx in ids] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tokens(self) -> List[str]:\n return self.tokens",
"def tokens(self):\n # type: () -> List[Token]\n return self._tokens",
"def tokens(self):\n return self.rpc.call(MsfRpcMethod.AuthTokenList)['tokens']",
"def get_tokens(self):\r\n return self.token_set",
"def get_token_lis... | [
"0.83647424",
"0.80425704",
"0.79461306",
"0.79414326",
"0.78283435",
"0.75734204",
"0.75067395",
"0.7500921",
"0.7500921",
"0.7500921",
"0.74711776",
"0.74703306",
"0.73524517",
"0.72486407",
"0.7219096",
"0.7147502",
"0.7132472",
"0.7059246",
"0.6929604",
"0.69008",
"0.6877... | 0.0 | -1 |
Convert `document` into the bagofwords (BoW) format = list of `(token_id, token_count)` tuples. | def doc2bow(self, document, allow_update=False, return_missing=False):
doc=[t.text for t in document.tokens]
if isinstance(doc, string_types):
raise TypeError("doc2bow expects an array of unicode tokens on input, not a single string")
# Construct (word, frequency) mapping.
counter = defaultdict(int)
for w in doc:
counter[w if isinstance(w, str) else str(w, 'utf-8')] += 1
token2id = self.token2id
if allow_update or return_missing:
missing = sorted(x for x in iteritems(counter) if x[0] not in token2id)
if allow_update:
for w, _ in missing:
# new id = number of ids made so far;
# NOTE this assumes there are no gaps in the id sequence!
token2id[w] = len(token2id)
result = {token2id[w]: freq for w, freq in iteritems(counter) if w in token2id}
if allow_update:
self.num_docs += 1
self.num_pos += sum(itervalues(counter))
self.num_nnz += len(result)
# keep track of document and collection frequencies
for tokenid, freq in iteritems(result):
self.cfs[tokenid] = self.cfs.get(tokenid, 0) + freq
self.dfs[tokenid] = self.dfs.get(tokenid, 0) + 1
# return tokenids, in ascending id order
result = sorted(iteritems(result))
if return_missing:
return result, dict(missing)
else:
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_bag_words(document_tokenized):\n bag_words = dict()\n for token in document_tokenized:\n if token in bag_words.keys():\n bag_words[token] += 1\n else:\n bag_words[token] = 1\n return bag_words",
"def sentencesToBow(documents):\n bowSentences = []\n dict... | [
"0.75598925",
"0.67602545",
"0.64582515",
"0.63520515",
"0.5917524",
"0.5897528",
"0.58469146",
"0.5783915",
"0.5782803",
"0.5771413",
"0.57590044",
"0.5732742",
"0.5720406",
"0.57064784",
"0.5675183",
"0.5654374",
"0.5644353",
"0.5635149",
"0.55853426",
"0.5584801",
"0.55662... | 0.6443913 | 3 |
Get the token_id of given token. | def token_to_id(self, token):
token = self.process_token(token)
return self.token2id.get(token, len(self.token2id) - 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def token_to_id(self, token):\n token = self.process_token(token)\n return self._token2id.get(token, len(self._token2id) - 1)",
"def token_to_id(self, token):\r\n return self.encoder.get(token, self.encoder.get(self.unk_token))",
"def token_id(self) -> Optional[pulumi.Input[int]]:\n ... | [
"0.8310672",
"0.7980398",
"0.79235566",
"0.7840283",
"0.7578476",
"0.730748",
"0.71591955",
"0.7151534",
"0.7099397",
"0.6803577",
"0.66393685",
"0.65554255",
"0.6520694",
"0.64726806",
"0.64626735",
"0.6437027",
"0.6431865",
"0.6408412",
"0.63829017",
"0.6313626",
"0.6299330... | 0.8298625 | 1 |
tokenid to token (string). | def id_to_token(self, idx):
return self._id2token[idx] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_id_to_token(self, id: int):\n return self._id_to_token[id]",
"def token_to_id(self, token):\r\n return self.encoder.get(token, self.encoder.get(self.unk_token))",
"def token_to_id(self, token):\n token = self.process_token(token)\n return self.token2id.get(token, len(self.to... | [
"0.7235237",
"0.69436103",
"0.6893987",
"0.6749872",
"0.67123127",
"0.6693682",
"0.6675571",
"0.6672998",
"0.6606152",
"0.66021",
"0.65837336",
"0.6532288",
"0.6484542",
"0.64636326",
"0.6327243",
"0.62979484",
"0.6255819",
"0.6240919",
"0.6239636",
"0.6181812",
"0.6127101",
... | 0.7267592 | 1 |
Return the vocabulary as a reversed dict object. | def reverse_vocab(self):
return self._id2token | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reverse_vocab(vocab: Dict[str, int]) -> Dict[int, str]:\n return {v: k for k, v in vocab.items()}",
"def reverse_dicts(self):\n\t\tself.rev_worddict = {self.worddict[word]: word for word in self.worddict}\n\t\tself.rev_classdict = {self.classdict[cl]: cl for cl in self.classdict}",
"def __reversed__(sel... | [
"0.77923155",
"0.6690991",
"0.6248791",
"0.6209789",
"0.6155369",
"0.6095056",
"0.60796165",
"0.60738266",
"0.606323",
"0.60227686",
"0.6020329",
"0.5977967",
"0.5962219",
"0.5951278",
"0.5935339",
"0.591856",
"0.591432",
"0.5899537",
"0.58708775",
"0.58708775",
"0.5850216",
... | 0.71455634 | 2 |
Update the current trigger. The GTM API does not support a partial update. Therfore, this method will send all fields expliztily set in the method arguments and those cached in the instance properties. | def update(self, refresh=False, parameter=None, **kwargs):
if refresh:
self.__init__(path=self._path, service=self.service)
default_asset = {
"maxTimerLengthSeconds": self._maxTimerLengthSeconds,
"totalTimeMinMilliseconds": self._totalTimeMinMilliseconds,
"uniqueTriggerId": self._uniqueTriggerId,
"verticalScrollPercentageList": self._verticalScrollPercentageList,
"horizontalScrollPercentageList": self._horizontalScrollPercentageList,
"containerId": self._containerId,
"waitForTagsTimeout": self._waitForTagsTimeout,
"accountId": self._accountId,
"waitForTags": self._waitForTags,
"intervalSeconds": self._intervalSeconds,
"eventName": self._eventName,
"visibilitySelector": self._visibilitySelector,
"workspaceId": self._workspaceId,
"customEventFilter": self._customEventFilter,
"parentFolderId": self._parentFolderId,
"continuousTimeMinMilliseconds": self._continuousTimeMinMilliseconds,
"selector": self._selector,
"triggerId": self._triggerId,
"tagManagerUrl": self._tagManagerUrl,
"fingerprint": self._fingerprint,
"visiblePercentageMax": self._visiblePercentageMax,
"path": self._path,
"name": self._name,
"visiblePercentageMin": self._visiblePercentageMin,
"type": self._type,
"notes": self._notes,
"interval": self._interval,
"filter": self._filter,
"autoEventFilter": self._autoEventFilter,
"limit": self._limit,
"checkValidation": self._checkValidation,
}
update_asset = {**default_asset, **kwargs}
if parameter:
parameter_dict = {**param_dict(self._parameter), **param_dict(parameter)}
parameter = list(parameter_dict.values())
else:
parameter = self._parameter
update_asset["parameter"] = [x.to_obj() for x in parameter]
update_asset = {k: v for k, v in update_asset.items() if v is not None}
request = self.triggers_service.update(path=self.path, body=update_asset)
response = request.execute()
self.__init__(trigger=response, service=self.service) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, *args, **kwargs):\n # callable, but does nothing by default",
"def update(self, *args, **kwargs):\n pass",
"def update(self, *args, **kwargs):\n pass",
"def update(self, *args, **kwargs):\n pass",
"def update(self, *args, **kwargs): # real signature unknown\n ... | [
"0.5962123",
"0.5947622",
"0.5947622",
"0.5947622",
"0.59135634",
"0.59135634",
"0.59135634",
"0.59135634",
"0.59135634",
"0.59135634",
"0.5901567",
"0.5882499",
"0.5750089",
"0.56001323",
"0.55886126",
"0.5582611",
"0.5573218",
"0.5543781",
"0.5498977",
"0.54955",
"0.5467472... | 0.56299794 | 13 |
Delete the current trigger. | def delete(self):
request = self.triggers_service.delete(path=self._path)
request.execute() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delTrigger(self, message: IRCMessage) -> IRCResponse:\n triggerName = message.parameterList[1]\n if triggerName in self.storage:\n del self.storage[triggerName]\n return IRCResponse(f\"Trigger {triggerName} deleted!\", message.replyTo)\n else:\n return IRC... | [
"0.7167729",
"0.70552254",
"0.6779274",
"0.6583904",
"0.655758",
"0.64790803",
"0.6461914",
"0.6461914",
"0.6461914",
"0.6461914",
"0.645271",
"0.64262265",
"0.62824124",
"0.6266517",
"0.62515134",
"0.62503153",
"0.62478745",
"0.62462974",
"0.6191452",
"0.61563873",
"0.615638... | 0.8082834 | 0 |
Create and return a D0 > hh' Selection object. | def makeD2hhAsymm(name,
config,
KPIDK_string,
PiPIDK_string,
Mass_low_string,
Mass_high_string,
CombPIDK_string,
DecayDescriptor,
inputSel,
useTOS,
Hlt1TOS,
Hlt2TOS
) :
def makeTISTOS( name, _input, _hlttos ) :
from Configurables import TisTosParticleTagger
_tisTosFilter = TisTosParticleTagger( name + "Tagger" )
_tisTosFilter.TisTosSpecs = _hlttos
return Selection( name
, Algorithm = _tisTosFilter
, RequiredSelections = [ _input ]
)
_Kcuts1 = "~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)" % locals()['config']
_KcutsPIDK = KPIDK_string % locals()['config']
_Kcuts2 = " & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)" % locals()['config']
_Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2
_Picuts1 = "~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)" % locals()['config']
_PicutsPIDK = PiPIDK_string % locals()['config']
_Picuts2 = " & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)" % locals()['config']
_Picuts = _Picuts1 + _PicutsPIDK + _Picuts2
_dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }
_massLow = Mass_low_string % locals()['config']
_massHigh = Mass_high_string % locals()['config']
_combCuts1 = "(APT > %(D0Pt)s* MeV)" \
"& (AHASCHILD( PT > %(DaugPtMax)s* MeV ) )" \
"& (ADOCA(1,2)< %(D0DOCA)s* mm)" \
"& (AP > %(D0P)s* MeV)" % locals()['config']
_combCutsPIDK = CombPIDK_string % locals()['config']
_combCuts = _combCuts1 + _combCutsPIDK + _massLow + _massHigh
_motherCuts = "(VFASPF(VCHI2PDOF) < %(D0VtxChi2Ndof)s)" \
"& (BPVVDCHI2 > %(D0FDChi2)s)" \
"& (BPVLTIME() > %(D0Tau)s)" \
"& (BPVDIRA > %(D0BPVDira)s)" % locals()['config']
_D0 = CombineParticles( DecayDescriptor = DecayDescriptor,
MotherCut = _motherCuts,
CombinationCut = _combCuts,
DaughtersCuts = _dauCuts)
_sel = Selection ( name+'Sel',
Algorithm = _D0,
RequiredSelections = inputSel )
if not useTOS:
return _sel
_selD2hhHlt1TOS = makeTISTOS( name + "D2hhHlt1TOS"
, _sel
, Hlt1TOS
)
_selD2hhHlt2TOS = makeTISTOS( name + "D2hhHlt2TOS"
, _selD2hhHlt1TOS
, Hlt2TOS
)
return _selD2hhHlt2TOS | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_selection(cls):\n guid = compas_rhino.select_point()\n return cls.from_guid(guid)",
"def get_slider():\n return dcc.RangeSlider(\n id='hours',\n value=[0, 23],\n min=0,\n max=23,\n marks={i: str(i) for i in range(0, 24, 3)}\n )",
"def from_selecti... | [
"0.5978266",
"0.5615562",
"0.53860027",
"0.53363514",
"0.52604216",
"0.5230591",
"0.5123659",
"0.5109732",
"0.5086925",
"0.50513536",
"0.50479877",
"0.5033334",
"0.49208",
"0.49170148",
"0.4872133",
"0.4828051",
"0.48176673",
"0.47932035",
"0.4729161",
"0.4611828",
"0.4548788... | 0.40723988 | 77 |
Create and return a D > D0 pi Selection object. | def makeDstar2D0Pi( name
, config
, DecayDescriptor
, inputSel
) :
daugCuts = "(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)" % locals()['config']
combCuts = "((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)" % locals()['config']
dstarCuts = "(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)" \
"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)" % locals()['config']
_Dstar = CombineParticles( DecayDescriptor = DecayDescriptor
, DaughtersCuts = { "pi+" : daugCuts }
, CombinationCut = combCuts
, MotherCut = dstarCuts
)
return Selection( name+'Sel',
Algorithm = _Dstar,
RequiredSelections = inputSel
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , se... | [
"0.60390633",
"0.5895539",
"0.55829453",
"0.5348063",
"0.5305103",
"0.5261155",
"0.5167734",
"0.51543236",
"0.5077886",
"0.5058524",
"0.50535107",
"0.50340015",
"0.5013713",
"0.49337313",
"0.49296355",
"0.48771095",
"0.48653218",
"0.48559302",
"0.48356175",
"0.48229763",
"0.4... | 0.6516377 | 0 |
Create and return a D > K pi pi+ Selection object. | def makeDPartial( name
, config
, DecayDescriptor
, inputSel
) :
_Kcuts1 = "~ISMUON & (PT > %(DaugPtLoose)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2Loose)s)" % locals()['config']
_KcutsPIDK = " & (PIDK > %(HighPIDK)s)" % locals()['config']
_Kcuts2 = " & (ISLONG) & (P > %(DaugPLoose)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2Loose)s)" % locals()['config']
_Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2
_Picuts1 = "~ISMUON & (PT > %(DaugPtMin)s* MeV) & (MIPCHI2DV(PRIMARY) > %(DaugIPChi2)s)" % locals()['config']
_PicutsPIDK = " & (PIDK < %(LowPIDK)s)" % locals()['config']
_Picuts2 = " & (ISLONG) & (P > %(DaugP)s* MeV) & (TRCHI2DOF < %(DaugTrkChi2)s)" % locals()['config']
_Picuts = _Picuts1 + _PicutsPIDK + _Picuts2
_dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }
#_Kcuts1 = "~ISMUON & (PT > 500* MeV) & (MIPCHI2DV(PRIMARY) > 4)"
#_KcutsPIDK = " & (PIDK > 5)"
#_Kcuts2 = " & (ISLONG) & (P > 5000* MeV) & (TRCHI2DOF < 5)"
#_Kcuts = _Kcuts1 + _KcutsPIDK + _Kcuts2
#_Picuts1 = "~ISMUON & (PT > 500* MeV) & (MIPCHI2DV(PRIMARY) > 4)"
#_PicutsPIDK = " & (PIDK < 0)"
#_Picuts2 = " & (ISLONG) & (P > 5000* MeV) & (TRCHI2DOF < 5)"
#_Picuts = _Picuts1 + _PicutsPIDK + _Picuts2
#_dauCuts = { 'K+': _Kcuts, 'pi+': _Picuts }
_combCuts = "(APT > %(D0PtLoose)s* MeV)" \
"& (AP > %(D0P)s* MeV)" % locals()['config']
_motherCuts = "(VFASPF(VCHI2PDOF) < %(D0VtxChi2Ndof)s)" \
"& (BPVVDCHI2 > %(D0FDChi2)s)" % locals()['config']
_Dminus = CombineParticles( DecayDescriptor = DecayDescriptor
, DaughtersCuts = _dauCuts
, CombinationCut = _combCuts
, MotherCut = _motherCuts
)
return Selection( name+'Sel',
Algorithm = _Dminus,
RequiredSelections = inputSel
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , se... | [
"0.656367",
"0.60201555",
"0.57468003",
"0.55250317",
"0.55029947",
"0.54665506",
"0.53652567",
"0.5354767",
"0.5222274",
"0.52220505",
"0.51531583",
"0.51516193",
"0.5116602",
"0.50792444",
"0.5024644",
"0.5015439",
"0.5015241",
"0.49948704",
"0.49836156",
"0.49750015",
"0.4... | 0.0 | -1 |
Create and return a D+ > D pi+ Selection object. | def makeDstarPartial( name
, config
, DecayDescriptor
, inputSel
) :
daugCuts = "(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)" % locals()['config']
combCuts = "((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)" % locals()['config']
dstarCuts = "(VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2VDOF_MAX)s)" \
"& ((M - M1) < %(Dstar_MDiff_MAX)s* MeV)" % locals()['config']
_Dstar = CombineParticles( DecayDescriptor = DecayDescriptor
, DaughtersCuts = { "pi+" : daugCuts }
, CombinationCut = combCuts
, MotherCut = dstarCuts
)
return Selection( name+'Sel',
Algorithm = _Dstar,
RequiredSelections = inputSel
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , se... | [
"0.63153064",
"0.5997607",
"0.5657909",
"0.5577311",
"0.55091554",
"0.5479855",
"0.52665573",
"0.5263441",
"0.51841724",
"0.5104352",
"0.50552374",
"0.49336368",
"0.49273384",
"0.49023122",
"0.4876281",
"0.48567244",
"0.4838079",
"0.48378935",
"0.47973046",
"0.47966853",
"0.4... | 0.5291082 | 6 |
Create and return a D > D0 pi Selection object. | def makePseudoPsi( name
, config
, DecayDescriptor
, inputSel
) :
_daugCuts = "(PT> %(D0PtLoose)s*MeV)" % locals()['config']
_combCuts = "(APT> %(D0PtLoose)s*MeV)" % locals()['config']
_Psi = CombineParticles( DecayDescriptor = DecayDescriptor
, DaughtersCuts = { "D0": _daugCuts }
, CombinationCut = _combCuts
, MotherCut = "(VFASPF(VCHI2PDOF) < 10000)"
)
return Selection( name+'Sel',
Algorithm = _Psi,
RequiredSelections = inputSel
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeDstar2D0Pi( name\n , config\n , DecayDescriptor\n , inputSel\n ) :\n\n daugCuts = \"(TRCHI2DOF < %(Daug_TRCHI2DOF_MAX)s)\" % locals()['config']\n combCuts = \"((AM - AM1) < %(Dstar_AMDiff_MAX)s* MeV)\" % locals()['config']\n ... | [
"0.65183586",
"0.6036616",
"0.58945334",
"0.55806303",
"0.5347493",
"0.53058124",
"0.5261733",
"0.51529664",
"0.50806415",
"0.5059661",
"0.50538725",
"0.50354403",
"0.5012788",
"0.4933138",
"0.49302754",
"0.48780695",
"0.48642525",
"0.4854433",
"0.4833495",
"0.48240137",
"0.4... | 0.5167268 | 7 |
dataloader for training dataset via voxsampler. | def load_train(trainlst, traindir, maptrain5994, L=L,
batch_size=batch_size, num_worker=num_worker,
max_utt_per_spk=max_utt_per_spk, load_wav=None):
if load_wav is None:
def load_train_wav(path): return loadWAV(path, L=L, evalmode=False)
else:
load_train_wav = load_wav
df_train = pd.read_csv(trainlst, sep=" ", header=None,
names=["speaker", "file"])
df_train["file"] = df_train["file"].apply(lambda x: traindir + x)
map_train = dict(pd.read_csv(maptrain5994, header=None).values)
data = voxceleb2(df_train.values, map_train, load_train_wav)
sampler = voxsampler(df_train, map_train,
max_utt_per_spk=max_utt_per_spk, batch_size=batch_size)
dataloader = DataLoader(data, batch_size=batch_size,
num_workers=num_worker, shuffle=False,
sampler=sampler)
return dataloader | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)",
"def dataloader(self):\n\n # load / split data\n train_data = self.data.get_train_data()\n if self.args.use_dev:\n train_data, de... | [
"0.7731121",
"0.7497621",
"0.72368264",
"0.71800596",
"0.7143441",
"0.7102657",
"0.7093028",
"0.7014497",
"0.6950995",
"0.6860976",
"0.6830999",
"0.67986304",
"0.6784964",
"0.6782085",
"0.67802626",
"0.6743672",
"0.6729586",
"0.6659931",
"0.66424596",
"0.6627726",
"0.6623991"... | 0.0 | -1 |
Computes the precision for the specified values of k | def accuracy(output, target, topk=(1,)):
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(100.0 / batch_size))
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def precision(gt, pred, k):\n k = min(len(pred), k)\n den = min(len(gt), k)\n return sum([int(pred[i] in gt) for i in range(k)]) / den",
"def precision_at_k(r, k):\n assert k >= 1\n r = np.asarray(r)[:k] != 0\n if r.size != k:\n raise ValueError('Relevance score length < k')\... | [
"0.76427615",
"0.74189496",
"0.7418079",
"0.72710466",
"0.72456723",
"0.72446615",
"0.7237539",
"0.72213703",
"0.7210107",
"0.7058935",
"0.6852219",
"0.6786084",
"0.67836976",
"0.6768417",
"0.67273885",
"0.67181736",
"0.67181736",
"0.67181736",
"0.67181736",
"0.67181736",
"0.... | 0.0 | -1 |
Calculate Equal Error Rate (EER). | def calculate_eer(y, y_score, pos=1):
fpr, tpr, thresholds = roc_curve(y, y_score, pos_label=pos)
eer = brentq(lambda x: 1. - x - interp1d(fpr, tpr)(x), 0., 1.)
thresh = interp1d(fpr, thresholds)(eer)
return eer, np.float(thresh) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_hr_ee(self):\n\n # HR - resting HR = net HR\n net_hr = np.array([i - self.rest_hr if i is not None else None for i in self.df_epoch[\"HR\"]])\n\n # Sets values below 0% HRR (below resting HR) to 0\n net_hr[net_hr <= 0] = 0\n\n # Equation from Brage et al., 2004. Act... | [
"0.6688616",
"0.6576088",
"0.6453312",
"0.6436712",
"0.6268617",
"0.61915094",
"0.60727984",
"0.60624784",
"0.6055529",
"0.5957637",
"0.5948924",
"0.5935441",
"0.59333384",
"0.5899245",
"0.5894991",
"0.5884183",
"0.5884183",
"0.5883016",
"0.5870002",
"0.5867805",
"0.58296996"... | 0.55544835 | 67 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.